@vived/host 3.0.0

package/lib/Components/Assets/Controllers/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("./archiveAsset"), exports);
+__exportStar(require("./deleteAsset"), exports);
+__exportStar(require("./downloadAssetFile"), exports);
+__exportStar(require("./getAppAssets"), exports);
+__exportStar(require("./toggleShowArchivedAssets"), exports);
+__exportStar(require("./updateAssetFile"), exports);

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggleShowArchivedAssets = void 0;
+const AppAssetsEntity_1 = require("../Entities/AppAssetsEntity");
+function toggleShowArchivedAssets(appObjects) {
+    const appAssets = AppAssetsEntity_1.AppAssetsEntity.get(appObjects);
+    if (appAssets) {
+        appAssets.showArchived = !appAssets.showArchived;
+    }
+    else {
+        appObjects.submitWarning('toggleShowArchivedAssets', 'Unable to find AppAssetsEntity');
+    }
+}
+exports.toggleShowArchivedAssets = toggleShowArchivedAssets;

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

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

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

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

package/lib/Components/Assets/Entities/AppAssetsEntity.d.ts

@@ -0,0 +1,15 @@
+import { HostAppObject, HostAppObjectEntity, HostAppObjectRepo } from '../../../HostAppObject';
+import { AssetEntity } from './AssetEntity';
+export declare abstract class AppAssetsEntity extends HostAppObjectEntity {
+    static type: string;
+    abstract getAll(): string[];
+    abstract add(assetID: string): void;
+    abstract has(assetID: string): boolean;
+    abstract remove(assetID: string): void;
+    abstract get editingAsset(): AssetEntity | undefined;
+    abstract set editingAsset(val: AssetEntity | undefined);
+    abstract get showArchived(): boolean;
+    abstract set showArchived(show: boolean);
+    static get(hostAppObjects: HostAppObjectRepo): AppAssetsEntity | undefined;
+}
+export declare function makeAppAssets(appObj: HostAppObject): AppAssetsEntity;

package/lib/Components/Assets/Entities/AppAssetsEntity.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppAssets = exports.AppAssetsEntity = void 0;
+const Entities_1 = require("../../../Entities");
+const HostAppObject_1 = require("../../../HostAppObject");
+class AppAssetsEntity extends HostAppObject_1.HostAppObjectEntity {
+    static get(hostAppObjects) {
+        return HostAppObject_1.getSingletonComponent(AppAssetsEntity.type, hostAppObjects);
+    }
+}
+exports.AppAssetsEntity = AppAssetsEntity;
+AppAssetsEntity.type = 'AppAssetsEntity';
+function makeAppAssets(appObj) {
+    return new AppAssetsImp(appObj);
+}
+exports.makeAppAssets = makeAppAssets;
+class AppAssetsImp extends AppAssetsEntity {
+    constructor(appObj) {
+        super(appObj, AppAssetsEntity.type);
+        this.appAssets = [];
+        this.getAll = () => {
+            return [...this.appAssets];
+        };
+        this.add = (assetID) => {
+            if (this.appAssets.includes(assetID))
+                return;
+            this.appAssets.push(assetID);
+            this.notifyOnChange();
+        };
+        this.memoizedShowArchived = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.appObjects.registerSingleton(this);
+    }
+    get editingAsset() {
+        return this._editingAsset;
+    }
+    set editingAsset(val) {
+        var _a;
+        if ((val === null || val === void 0 ? void 0 : val.id) === ((_a = this._editingAsset) === null || _a === void 0 ? void 0 : _a.id))
+            return;
+        if (this._editingAsset) {
+            this._editingAsset.removeChangeObserver(this.notifyOnChange);
+        }
+        this._editingAsset = val;
+        if (this._editingAsset) {
+            this._editingAsset.addChangeObserver(this.notifyOnChange);
+        }
+        this.notifyOnChange();
+    }
+    has(assetID) {
+        return this.appAssets.includes(assetID);
+    }
+    remove(assetID) {
+        const index = this.appAssets.indexOf(assetID, 0);
+        if (index > -1) {
+            this.appAssets.splice(index, 1);
+            this.notifyOnChange();
+        }
+    }
+    get showArchived() {
+        return this.memoizedShowArchived.val;
+    }
+    set showArchived(show) {
+        this.memoizedShowArchived.val = show;
+    }
+}

package/lib/Components/Assets/Entities/AssetEntity.d.ts

@@ -0,0 +1,34 @@
+import { HostAppObject, HostAppObjectEntity } from '../../../HostAppObject';
+export declare abstract class AssetEntity extends HostAppObjectEntity {
+    static type: string;
+    abstract readonly id: string;
+    abstract get name(): string;
+    abstract set name(name: string);
+    abstract get description(): string;
+    abstract set description(description: string);
+    abstract get owner(): string;
+    abstract set owner(val: string);
+    abstract get archived(): boolean;
+    abstract set archived(archived: boolean);
+    abstract get filename(): string;
+    abstract set filename(filename: string);
+    abstract get fileURL(): string;
+    abstract set fileURL(fileURL: string);
+    abstract setFile(file: File): void;
+    abstract get file(): File | undefined;
+    abstract get blobURL(): string | undefined;
+    abstract get fileHasBeenFetched(): boolean;
+    abstract get linkedAssets(): {
+        type: string;
+        id: string;
+    }[];
+    abstract addLinkedAsset(type: string, id: string): void;
+    abstract removeLinkedAsset(type: string, id: string): void;
+    abstract getLinkedAssetByType(type: string): string[];
+    abstract get isFetchingFile(): boolean;
+    abstract set isFetchingFile(isFetchingFile: boolean);
+    abstract get fetchError(): Error | undefined;
+    abstract set fetchError(fetchError: Error | undefined);
+    static get(appObject: HostAppObject): AssetEntity | undefined;
+}
+export declare function makeAssetEntity(appObject: HostAppObject): AssetEntity;

package/lib/Components/Assets/Entities/AssetEntity.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAssetEntity = exports.AssetEntity = void 0;
+const Entities_1 = require("../../../Entities");
+const HostAppObject_1 = require("../../../HostAppObject");
+class AssetEntity extends HostAppObject_1.HostAppObjectEntity {
+    static get(appObject) {
+        const asset = appObject.getComponent(AssetEntity.type);
+        if (!asset) {
+            appObject.appObjectRepo.submitWarning('AssetEntity.get', 'Unable to find AssetEntity on app object ' + appObject.id);
+        }
+        return asset;
+    }
+}
+exports.AssetEntity = AssetEntity;
+AssetEntity.type = 'AssetEntity';
+function makeAssetEntity(appObject) {
+    return new AssetImp(appObject);
+}
+exports.makeAssetEntity = makeAssetEntity;
+class AssetImp extends AssetEntity {
+    constructor(appObject) {
+        super(appObject, AssetEntity.type);
+        this._memoizedName = new Entities_1.MemoizedString('', this.notifyOnChange);
+        this._memoizedOwner = new Entities_1.MemoizedString('', this.notifyOnChange);
+        this._memoizedDescription = new Entities_1.MemoizedString('', this.notifyOnChange);
+        this._memoizedArchived = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this._memoizedFileURL = new Entities_1.MemoizedString('', this.notifyOnChange);
+        this._memoizedFilename = new Entities_1.MemoizedString('', this.notifyOnChange);
+        this._file = undefined;
+        this._blobURL = undefined;
+        this.setFile = (file) => {
+            this._file = file;
+            this._blobURL = URL.createObjectURL(file);
+            this.notifyOnChange();
+        };
+        this._linkedAssets = [];
+        this.addLinkedAsset = (type, id) => {
+            const existingAsset = this._linkedAssets.find((asset) => {
+                return asset.id === id;
+            });
+            if (existingAsset === undefined) {
+                this._linkedAssets.push({
+                    id,
+                    type,
+                });
+                this.notifyOnChange();
+            }
+        };
+        this.removeLinkedAsset = (type, id) => {
+            let foundAsset = false;
+            this._linkedAssets.forEach((asset) => {
+                if (asset.type === type && asset.id === id) {
+                    foundAsset = true;
+                }
+            });
+            if (foundAsset) {
+                this._linkedAssets = this._linkedAssets.filter((asset) => asset.id !== id);
+                this.notifyOnChange();
+            }
+        };
+        this.getLinkedAssetByType = (type) => {
+            const rVal = [];
+            this._linkedAssets.forEach((asset) => {
+                if (asset.type === type) {
+                    rVal.push(asset.id);
+                }
+            });
+            return rVal;
+        };
+        this._memoizedIsFetchingFile = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this._fetchError = undefined;
+        this.dispose = () => {
+            if (this._blobURL !== undefined) {
+                URL.revokeObjectURL(this._blobURL);
+                this._blobURL = undefined;
+                this.notifyOnChange();
+            }
+            super.dispose();
+        };
+    }
+    get id() {
+        return this.appObject.id;
+    }
+    get name() {
+        return this._memoizedName.val;
+    }
+    set name(name) {
+        this._memoizedName.val = name;
+    }
+    get owner() {
+        return this._memoizedOwner.val;
+    }
+    set owner(val) {
+        this._memoizedOwner.val = val;
+    }
+    get description() {
+        return this._memoizedDescription.val;
+    }
+    set description(description) {
+        this._memoizedDescription.val = description;
+    }
+    get archived() {
+        return this._memoizedArchived.val;
+    }
+    set archived(archived) {
+        this._memoizedArchived.val = archived;
+    }
+    get filename() {
+        return this._memoizedFilename.val;
+    }
+    set filename(name) {
+        this._memoizedFilename.val = name;
+    }
+    get fileURL() {
+        return this._memoizedFileURL.val;
+    }
+    set fileURL(name) {
+        this._memoizedFileURL.val = name;
+    }
+    get file() {
+        return this._file;
+    }
+    get blobURL() {
+        return this._blobURL;
+    }
+    get fileHasBeenFetched() {
+        return this._file !== undefined;
+    }
+    get linkedAssets() {
+        return [...this._linkedAssets];
+    }
+    get isFetchingFile() {
+        return this._memoizedIsFetchingFile.val;
+    }
+    set isFetchingFile(archived) {
+        this._memoizedIsFetchingFile.val = archived;
+    }
+    get fetchError() {
+        return this._fetchError;
+    }
+    set fetchError(fetchError) {
+        if (fetchError === undefined && this.fetchError === undefined)
+            return;
+        if (fetchError !== undefined && this.fetchError !== undefined && fetchError.message === this.fetchError.message)
+            return;
+        this._fetchError = fetchError;
+        this.notifyOnChange();
+    }
+}

package/lib/Components/Assets/Entities/AssetRepo.d.ts

@@ -0,0 +1,28 @@
+import { HostAppObject, HostAppObjectEntity, HostAppObjectRepo } from '../../../HostAppObject';
+import { AssetEntity } from './AssetEntity';
+export interface AssetDTO {
+    id: string;
+    ownerId: string;
+    name: string;
+    description: string;
+    archived: boolean;
+    filename: string;
+    fileURL: string;
+    linkedAssets: {
+        type: string;
+        asset: AssetDTO;
+    }[];
+}
+export declare abstract class AssetRepo extends HostAppObjectEntity {
+    static type: string;
+    abstract add(asset: AssetEntity): void;
+    abstract has(id: string): boolean;
+    abstract get(assetID: string): AssetEntity | undefined;
+    abstract getOrCreate(assetID: string): AssetEntity;
+    abstract getAll(): AssetEntity[];
+    abstract remove(assetID: string): void;
+    abstract assetFactory(id: string): AssetEntity;
+    abstract addFromDTO(dto: AssetDTO): AssetEntity;
+    static get(hostAppObjects: HostAppObjectRepo): AssetRepo | undefined;
+}
+export declare function makeAssetRepo(appObj: HostAppObject): AssetRepo;

package/lib/Components/Assets/Entities/AssetRepo.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAssetRepo = exports.AssetRepo = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const AssetEntity_1 = require("./AssetEntity");
+class AssetRepo extends HostAppObject_1.HostAppObjectEntity {
+    static get(hostAppObjects) {
+        return HostAppObject_1.getSingletonComponent(AssetRepo.type, hostAppObjects);
+    }
+}
+exports.AssetRepo = AssetRepo;
+AssetRepo.type = 'AssetRepository';
+function makeAssetRepo(appObj) {
+    return new AssetRepositoryImp(appObj);
+}
+exports.makeAssetRepo = makeAssetRepo;
+class AssetRepositoryImp extends AssetRepo {
+    constructor(appObj) {
+        super(appObj, AssetRepo.type);
+        this.assetLookup = new Map();
+        this.has = (id) => {
+            return this.assetLookup.has(id);
+        };
+        this.assetFactory = (id) => {
+            this.error('Asset factory has not been injected');
+            return AssetEntity_1.makeAssetEntity(this.appObjects.getOrCreate(id));
+        };
+        this.add = (asset) => {
+            if (this.assetLookup.has(asset.id))
+                return;
+            this.assetLookup.set(asset.id, asset);
+            this.notifyOnChange();
+        };
+        this.get = (assetID) => {
+            return this.assetLookup.get(assetID);
+        };
+        this.getOrCreate = (assetID) => {
+            const existing = this.assetLookup.get(assetID);
+            if (existing) {
+                return existing;
+            }
+            const newAsset = this.assetFactory(assetID);
+            this.add(newAsset);
+            return newAsset;
+        };
+        this.getAll = () => {
+            return Array.from(this.assetLookup.values());
+        };
+        this.remove = (assetID) => {
+            if (!this.assetLookup.has(assetID))
+                return;
+            this.assetLookup.delete(assetID);
+            this.notifyOnChange();
+        };
+        this.setAssetFromDTO = (data, asset) => {
+            asset.description = data.description;
+            asset.name = data.name;
+            asset.archived = data.archived;
+            asset.filename = data.filename;
+            asset.owner = data.ownerId;
+            asset.fileURL = data.fileURL;
+            data.linkedAssets.forEach((linkedAsset) => {
+                asset.addLinkedAsset(linkedAsset.type, linkedAsset.asset.id);
+            });
+            return asset;
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    addFromDTO(dto) {
+        const baseAsset = this.getOrCreate(dto.id);
+        this.setAssetFromDTO(dto, baseAsset);
+        const allLinkedDTOs = [];
+        this.addLinkedAssetDTOsRecursively(dto.linkedAssets, allLinkedDTOs);
+        allLinkedDTOs.forEach((linkedDTO) => {
+            const asset = this.getOrCreate(linkedDTO.id);
+            this.setAssetFromDTO(linkedDTO, asset);
+        });
+        return baseAsset;
+    }
+    addLinkedAssetDTOsRecursively(linkedAssetList, metaList) {
+        linkedAssetList.forEach((linkedAsset) => {
+            metaList.push(linkedAsset.asset);
+            this.addLinkedAssetDTOsRecursively(linkedAsset.asset.linkedAssets, metaList);
+        });
+    }
+}

package/lib/Components/Assets/Entities/AssetRepository.d.ts

@@ -0,0 +1,34 @@
+import { AssetDTO, NewAssetDTO, UpdateAssetDTO } from '../../../Entities';
+import { HostAppObject, HostAppObjectEntity } from '../../../HostAppObject';
+import { AssetEntity } from './AssetEntity';
+export interface APIComms {
+    getAssetFile: (assetID: string) => Promise<File>;
+    getAssetMeta: (assetID: string) => Promise<AssetDTO>;
+    getAssetsForOwner: (ownerID: string) => Promise<AssetDTO[]>;
+    updateArchiveAsset: (assetID: string, archived: boolean) => Promise<void>;
+    updateAssetMeta: (data: AssetDTO) => Promise<void>;
+    createNewAsset: (data: NewAssetDTO) => Promise<string>;
+    updateAssetFile: (assetID: string, file: File) => Promise<void>;
+    deleteAsset: (assetID: string) => Promise<void>;
+    updateAsset: (data: UpdateAssetDTO) => Promise<AssetDTO>;
+}
+export declare abstract class AssetRepository extends HostAppObjectEntity {
+    static type: string;
+    abstract set apiComms(comms: APIComms);
+    abstract addAsset(asset: AssetEntity): void;
+    abstract hasFetchedAsset(assetID: string): boolean;
+    abstract getFetchedAsset(assetID: string): AssetEntity | undefined;
+    abstract getAsset(assetID: string): Promise<AssetEntity>;
+    abstract getAssetBlobURL(assetID: string): Promise<string>;
+    abstract getAssetsForOwner(ownerID: string): Promise<AssetEntity[]>;
+    abstract setAssetArchived(assetID: string, archive: boolean): Promise<void>;
+    abstract updateAssetMeta(data: AssetDTO): Promise<void>;
+    abstract newAsset(data: NewAssetDTO): Promise<AssetEntity>;
+    abstract updateAssetFile(assetID: string, file: File): Promise<void>;
+    abstract deleteAsset(assetID: string): Promise<void>;
+    abstract updateAsset(data: UpdateAssetDTO): Promise<AssetDTO>;
+    abstract assetFactory(id: string): AssetEntity;
+}
+export declare function makeAssetRepository(appObj: HostAppObject): AssetRepository;
+export declare const NO_API_COMMS_ERROR: Error;
+export declare const NO_ASSET_ERROR: Error;