@vived/host 3.0.0

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

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_ASSET_ERROR = exports.NO_API_COMMS_ERROR = exports.makeAssetRepository = exports.AssetRepository = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+class AssetRepository extends HostAppObject_1.HostAppObjectEntity {
+}
+exports.AssetRepository = AssetRepository;
+AssetRepository.type = 'AssetRepository';
+function makeAssetRepository(appObj) {
+    return new AssetRepositoryImp(appObj);
+}
+exports.makeAssetRepository = makeAssetRepository;
+class AssetRepositoryImp extends AssetRepository {
+    constructor(appObj) {
+        super(appObj, AssetRepository.type);
+        this.assetLookup = new Map();
+        this.updateAsset = (data) => {
+            if (!this._apiComms) {
+                return Promise.reject(exports.NO_API_COMMS_ERROR);
+            }
+            const asset = this.assetLookup.get(data.id);
+            if (!asset) {
+                return Promise.reject(exports.NO_ASSET_ERROR);
+            }
+            return new Promise((resolve, reject) => {
+                this._apiComms.updateAsset(data)
+                    .then((updatedAsset) => {
+                    asset.name = updatedAsset.name;
+                    asset.description = updatedAsset.description;
+                    asset.archived = updatedAsset.archived;
+                    resolve(updatedAsset);
+                })
+                    .catch((e) => {
+                    reject(e);
+                });
+            });
+        };
+        this.updateAssetMeta = (data) => {
+            if (!this._apiComms) {
+                return Promise.reject(exports.NO_API_COMMS_ERROR);
+            }
+            const asset = this.assetLookup.get(data.id);
+            if (!asset) {
+                return Promise.reject(exports.NO_ASSET_ERROR);
+            }
+            if (asset.name === data.name && ((asset.description === data.description) === asset.archived) === data.archived) {
+                return Promise.resolve();
+            }
+            return new Promise((resolve, reject) => {
+                this._apiComms.updateAssetMeta(data)
+                    .then((_) => {
+                    asset.name = data.name;
+                    asset.description = data.description;
+                    asset.archived = data.archived;
+                    resolve();
+                })
+                    .catch((e) => {
+                    reject(e);
+                });
+            });
+        };
+        this.hasFetchedAsset = (assetID) => {
+            return this.assetLookup.has(assetID);
+        };
+        this.getFetchedAsset = (assetID) => {
+            return this.assetLookup.get(assetID);
+        };
+        this.getAssetBlobURL = (assetID) => {
+            if (!this._apiComms) {
+                return Promise.reject(exports.NO_API_COMMS_ERROR);
+            }
+            const existingAsset = this.assetLookup.get(assetID);
+            if (existingAsset) {
+                if (existingAsset.blobURL) {
+                    return Promise.resolve(existingAsset.blobURL);
+                }
+                else {
+                    return new Promise((resolve, reject) => {
+                        this._apiComms.getAssetFile(assetID)
+                            .then((file) => {
+                            existingAsset.setFile(file);
+                            if (existingAsset.blobURL) {
+                                resolve(existingAsset.blobURL);
+                            }
+                            else {
+                                reject(new Error('Blob URL is empty'));
+                            }
+                        })
+                            .catch((e) => {
+                            reject(e);
+                        });
+                    });
+                }
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    this._apiComms.getAssetMeta(assetID)
+                        .then((assetMeta) => {
+                        this._apiComms.getAssetFile(assetID)
+                            .then((url) => {
+                            const asset = this.assetFromDTO(assetMeta);
+                            asset.setFile(url);
+                            this.assetLookup.set(assetID, asset);
+                            if (asset.blobURL) {
+                                resolve(asset.blobURL);
+                            }
+                            else {
+                                reject(new Error('Blob URL is empty'));
+                            }
+                        })
+                            .catch((e) => {
+                            reject(e);
+                        });
+                    })
+                        .catch((e) => {
+                        reject(e);
+                    });
+                });
+            }
+        };
+        this.addAsset = (asset) => {
+            if (this.assetLookup.has(asset.id))
+                return;
+            this.assetLookup.set(asset.id, asset);
+        };
+        this.getAsset = (assetID) => {
+            if (!this._apiComms) {
+                return Promise.reject(exports.NO_API_COMMS_ERROR);
+            }
+            const existingAsset = this.assetLookup.get(assetID);
+            if (existingAsset) {
+                return Promise.resolve(existingAsset);
+            }
+            return new Promise((resolve, reject) => {
+                this._apiComms.getAssetMeta(assetID)
+                    .then((assetMeta) => {
+                    const asset = this.assetFromDTO(assetMeta);
+                    this.assetLookup.set(assetID, asset);
+                    resolve(asset);
+                })
+                    .catch((error) => {
+                    reject(error);
+                });
+            });
+        };
+        this.getAssetsForOwner = (ownerID) => {
+            if (!this._apiComms) {
+                return Promise.reject(exports.NO_API_COMMS_ERROR);
+            }
+            return new Promise((resolve, reject) => {
+                var _a;
+                (_a = this._apiComms) === null || _a === void 0 ? void 0 : _a.getAssetsForOwner(ownerID).then((ownedAssetMetas) => {
+                    const ownedAssets = [];
+                    ownedAssetMetas.forEach((assetMeta) => {
+                        const asset = this.assetFromDTO(assetMeta);
+                        ownedAssets.push(asset);
+                        if (!this.assetLookup.has(assetMeta.id)) {
+                            this.assetLookup.set(assetMeta.id, asset);
+                        }
+                    });
+                    resolve(ownedAssets);
+                }).catch((e) => {
+                    reject(e);
+                });
+            });
+        };
+        this.assetFromDTO = (meta) => {
+            const asset = this.assetFactory(meta.id);
+            asset.description = meta.description;
+            asset.name = meta.name;
+            asset.archived = meta.archived;
+            asset.filename = meta.filename;
+            return asset;
+        };
+        this.setAssetArchived = (assetID, archive) => {
+            if (!this._apiComms) {
+                return Promise.reject(exports.NO_API_COMMS_ERROR);
+            }
+            const asset = this.assetLookup.get(assetID);
+            if (!asset) {
+                return Promise.reject(exports.NO_ASSET_ERROR);
+            }
+            if (asset.archived === archive) {
+                return Promise.resolve();
+            }
+            return new Promise((resolve, reject) => {
+                this._apiComms.updateArchiveAsset(assetID, archive)
+                    .then(() => {
+                    asset.archived = archive;
+                    resolve();
+                })
+                    .catch((e) => {
+                    reject(e);
+                });
+            });
+        };
+        this.newAsset = (data) => {
+            if (!this._apiComms) {
+                return Promise.reject(exports.NO_API_COMMS_ERROR);
+            }
+            return new Promise((resolve, reject) => {
+                this._apiComms.createNewAsset(data)
+                    .then((assetId) => {
+                    const asset = this.assetFactory(assetId);
+                    asset.description = data.description;
+                    asset.name = data.name;
+                    asset.archived = false;
+                    asset.filename = data.file.name;
+                    this.assetLookup.set(asset.id, asset);
+                    resolve(asset);
+                })
+                    .catch((error) => {
+                    reject(error);
+                });
+            });
+        };
+        this.updateAssetFile = (assetID, file) => {
+            if (!this._apiComms) {
+                return Promise.reject(exports.NO_API_COMMS_ERROR);
+            }
+            const asset = this.assetLookup.get(assetID);
+            if (!asset) {
+                return Promise.reject(exports.NO_ASSET_ERROR);
+            }
+            return new Promise((resolve, reject) => {
+                this._apiComms.updateAssetFile(assetID, file)
+                    .then((_) => {
+                    return this._apiComms.getAssetFile(assetID);
+                })
+                    .then((blobURL) => {
+                    asset.setFile(blobURL);
+                    resolve();
+                })
+                    .catch((error) => {
+                    reject(error);
+                });
+            });
+        };
+        this.deleteAsset = (assetID) => {
+            if (!this._apiComms) {
+                return Promise.reject(exports.NO_API_COMMS_ERROR);
+            }
+            const asset = this.assetLookup.get(assetID);
+            if (!asset) {
+                return Promise.reject(exports.NO_ASSET_ERROR);
+            }
+            return new Promise((resolve, reject) => {
+                this._apiComms.deleteAsset(assetID)
+                    .then((_) => {
+                    this.assetLookup.delete(assetID);
+                    resolve();
+                })
+                    .catch((error) => {
+                    reject(error);
+                });
+            });
+        };
+    }
+    set apiComms(comms) {
+        this._apiComms = comms;
+    }
+    assetFactory(id) {
+        throw new Error('Asset factory has not been injected');
+    }
+}
+exports.NO_API_COMMS_ERROR = new Error('API Communications have not been injected');
+exports.NO_ASSET_ERROR = new Error('Unable to find asset by id');

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

@@ -0,0 +1,3 @@
+export * from './AppAssetsEntity';
+export * from './AssetEntity';
+export * from './AssetRepo';

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

@@ -0,0 +1,15 @@
+"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("./AppAssetsEntity"), exports);
+__exportStar(require("./AssetEntity"), exports);
+__exportStar(require("./AssetRepo"), exports);

package/lib/Components/Assets/Mocks/MockArchiveAsset.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { ArchiveAssetUC } from "../UCs/ArchiveAssetUC";
+export declare class MockArchiveAssetUC extends ArchiveAssetUC {
+    setArchived: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockArchiveAssetUC(appObjects: HostAppObjectRepo): MockArchiveAssetUC;

package/lib/Components/Assets/Mocks/MockArchiveAsset.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockArchiveAssetUC = exports.MockArchiveAssetUC = void 0;
+const ArchiveAssetUC_1 = require("../UCs/ArchiveAssetUC");
+class MockArchiveAssetUC extends ArchiveAssetUC_1.ArchiveAssetUC {
+    constructor(appObject) {
+        super(appObject, ArchiveAssetUC_1.ArchiveAssetUC.type);
+        this.setArchived = jest.fn().mockResolvedValue(undefined);
+    }
+}
+exports.MockArchiveAssetUC = MockArchiveAssetUC;
+function makeMockArchiveAssetUC(appObjects) {
+    return new MockArchiveAssetUC(appObjects.getOrCreate("MockArchiveAssetUC"));
+}
+exports.makeMockArchiveAssetUC = makeMockArchiveAssetUC;

package/lib/Components/Assets/Mocks/MockDeleteAssetUC.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { DeleteAssetUC } from "../UCs/DeleteAssetUC";
+export declare class MockDeleteAssetUC extends DeleteAssetUC {
+    delete: jest.Mock<any, any>;
+    deleteWithConfirm: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockDeleteAssetUC(appObjects: HostAppObjectRepo): MockDeleteAssetUC;

package/lib/Components/Assets/Mocks/MockDeleteAssetUC.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockDeleteAssetUC = exports.MockDeleteAssetUC = void 0;
+const DeleteAssetUC_1 = require("../UCs/DeleteAssetUC");
+class MockDeleteAssetUC extends DeleteAssetUC_1.DeleteAssetUC {
+    constructor(appObject) {
+        super(appObject, DeleteAssetUC_1.DeleteAssetUC.type);
+        this.delete = jest.fn().mockResolvedValue(undefined);
+        this.deleteWithConfirm = jest.fn();
+    }
+}
+exports.MockDeleteAssetUC = MockDeleteAssetUC;
+function makeMockDeleteAssetUC(appObjects) {
+    return new MockDeleteAssetUC(appObjects.getOrCreate("MockDeleteAssetUC"));
+}
+exports.makeMockDeleteAssetUC = makeMockDeleteAssetUC;

package/lib/Components/Assets/Mocks/MockDownloadAssetFileUC.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { DownloadAssetFileUC } from "../UCs/DownloadAssetFileUC";
+export declare class MockDownloadAssetFileUC extends DownloadAssetFileUC {
+    download: jest.Mock<any, any>;
+    saveFileLocally: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockDownloadAssetFileUC(appObjects: HostAppObjectRepo): MockDownloadAssetFileUC;

package/lib/Components/Assets/Mocks/MockDownloadAssetFileUC.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockDownloadAssetFileUC = exports.MockDownloadAssetFileUC = void 0;
+const DownloadAssetFileUC_1 = require("../UCs/DownloadAssetFileUC");
+class MockDownloadAssetFileUC extends DownloadAssetFileUC_1.DownloadAssetFileUC {
+    constructor(appObject) {
+        super(appObject, DownloadAssetFileUC_1.DownloadAssetFileUC.type);
+        this.download = jest.fn();
+        this.saveFileLocally = jest.fn();
+    }
+}
+exports.MockDownloadAssetFileUC = MockDownloadAssetFileUC;
+function makeMockDownloadAssetFileUC(appObjects) {
+    return new MockDownloadAssetFileUC(appObjects.getOrCreate("MockDownloadAssetFileUC"));
+}
+exports.makeMockDownloadAssetFileUC = makeMockDownloadAssetFileUC;

package/lib/Components/Assets/Mocks/MockGetAppAssetsUC.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { GetAppAssetsUC } from "../UCs/GetAppAssetsUC";
+export declare class MockGetAppAssetsUC extends GetAppAssetsUC {
+    getAppAssets: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockGetAppAssetsUC(appObjects: HostAppObjectRepo): MockGetAppAssetsUC;

package/lib/Components/Assets/Mocks/MockGetAppAssetsUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockGetAppAssetsUC = exports.MockGetAppAssetsUC = void 0;
+const GetAppAssetsUC_1 = require("../UCs/GetAppAssetsUC");
+class MockGetAppAssetsUC extends GetAppAssetsUC_1.GetAppAssetsUC {
+    constructor(appObject) {
+        super(appObject, GetAppAssetsUC_1.GetAppAssetsUC.type);
+        this.getAppAssets = jest.fn();
+    }
+}
+exports.MockGetAppAssetsUC = MockGetAppAssetsUC;
+function makeMockGetAppAssetsUC(appObjects) {
+    return new MockGetAppAssetsUC(appObjects.getOrCreate("MockGetAppAssetsUC"));
+}
+exports.makeMockGetAppAssetsUC = makeMockGetAppAssetsUC;

package/lib/Components/Assets/Mocks/MockGetAssetBlobURLUC.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { GetAssetBlobURLUC } from "../UCs/GetAssetBlobURLUC";
+export declare class MockGetAssetBlobURLUC extends GetAssetBlobURLUC {
+    getAssetBlobURL: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockGetAssetBlobURLUC(appObjects: HostAppObjectRepo): MockGetAssetBlobURLUC;

package/lib/Components/Assets/Mocks/MockGetAssetBlobURLUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockGetAssetBlobURLUC = exports.MockGetAssetBlobURLUC = void 0;
+const GetAssetBlobURLUC_1 = require("../UCs/GetAssetBlobURLUC");
+class MockGetAssetBlobURLUC extends GetAssetBlobURLUC_1.GetAssetBlobURLUC {
+    constructor(appObject) {
+        super(appObject, GetAssetBlobURLUC_1.GetAssetBlobURLUC.type);
+        this.getAssetBlobURL = jest.fn().mockResolvedValue("www.someBlobURL.com");
+    }
+}
+exports.MockGetAssetBlobURLUC = MockGetAssetBlobURLUC;
+function makeMockGetAssetBlobURLUC(appObjects) {
+    return new MockGetAssetBlobURLUC(appObjects.getOrCreate("MockGetAssetUC"));
+}
+exports.makeMockGetAssetBlobURLUC = makeMockGetAssetBlobURLUC;

package/lib/Components/Assets/Mocks/MockGetAssetFileUC.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { GetAssetFileUC } from "../UCs/GetAssetFileUC";
+export declare class MockGetAssetFileUC extends GetAssetFileUC {
+    getAssetFile: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockGetAssetFileUC(appObjects: HostAppObjectRepo): MockGetAssetFileUC;

package/lib/Components/Assets/Mocks/MockGetAssetFileUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockGetAssetFileUC = exports.MockGetAssetFileUC = void 0;
+const GetAssetFileUC_1 = require("../UCs/GetAssetFileUC");
+class MockGetAssetFileUC extends GetAssetFileUC_1.GetAssetFileUC {
+    constructor(appObject) {
+        super(appObject, GetAssetFileUC_1.GetAssetFileUC.type);
+        this.getAssetFile = jest.fn();
+    }
+}
+exports.MockGetAssetFileUC = MockGetAssetFileUC;
+function makeMockGetAssetFileUC(appObjects) {
+    return new MockGetAssetFileUC(appObjects.getOrCreate("MockGetAssetFileUC"));
+}
+exports.makeMockGetAssetFileUC = makeMockGetAssetFileUC;

package/lib/Components/Assets/Mocks/MockGetAssetUC.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { GetAssetUC } from "../UCs/GetAssetUC";
+export declare class MockGetAssetUC extends GetAssetUC {
+    getAsset: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockGetAssetUC(appObjects: HostAppObjectRepo): MockGetAssetUC;

package/lib/Components/Assets/Mocks/MockGetAssetUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockGetAssetUC = exports.MockGetAssetUC = void 0;
+const GetAssetUC_1 = require("../UCs/GetAssetUC");
+class MockGetAssetUC extends GetAssetUC_1.GetAssetUC {
+    constructor(appObject) {
+        super(appObject, GetAssetUC_1.GetAssetUC.type);
+        this.getAsset = jest.fn();
+    }
+}
+exports.MockGetAssetUC = MockGetAssetUC;
+function makeMockGetAssetUC(appObjects) {
+    return new MockGetAssetUC(appObjects.getOrCreate("MockGetAssetUC"));
+}
+exports.makeMockGetAssetUC = makeMockGetAssetUC;

package/lib/Components/Assets/Mocks/MockUpdateAssetFileUC.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { UpdateAssetFileUC } from "../UCs/UpdateAssetFileUC";
+export declare class MockUpdateAssetFileUC extends UpdateAssetFileUC {
+    updateFile: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockUpdateAssetFileUC(appObjects: HostAppObjectRepo): MockUpdateAssetFileUC;

package/lib/Components/Assets/Mocks/MockUpdateAssetFileUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockUpdateAssetFileUC = exports.MockUpdateAssetFileUC = void 0;
+const UpdateAssetFileUC_1 = require("../UCs/UpdateAssetFileUC");
+class MockUpdateAssetFileUC extends UpdateAssetFileUC_1.UpdateAssetFileUC {
+    constructor(appObject) {
+        super(appObject, UpdateAssetFileUC_1.UpdateAssetFileUC.type);
+        this.updateFile = jest.fn().mockResolvedValue("newFile.name");
+    }
+}
+exports.MockUpdateAssetFileUC = MockUpdateAssetFileUC;
+function makeMockUpdateAssetFileUC(appObjects) {
+    return new MockUpdateAssetFileUC(appObjects.getOrCreate("MockUpdateAssetFileUC"));
+}
+exports.makeMockUpdateAssetFileUC = makeMockUpdateAssetFileUC;

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

@@ -0,0 +1,8 @@
+export * from './MockArchiveAsset';
+export * from './MockDeleteAssetUC';
+export * from './MockDownloadAssetFileUC';
+export * from './MockGetAppAssetsUC';
+export * from './MockGetAssetBlobURLUC';
+export * from './MockGetAssetFileUC';
+export * from './MockGetAssetUC';
+export * from './MockUpdateAssetFileUC';

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

@@ -0,0 +1,20 @@
+"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("./MockArchiveAsset"), exports);
+__exportStar(require("./MockDeleteAssetUC"), exports);
+__exportStar(require("./MockDownloadAssetFileUC"), exports);
+__exportStar(require("./MockGetAppAssetsUC"), exports);
+__exportStar(require("./MockGetAssetBlobURLUC"), exports);
+__exportStar(require("./MockGetAssetFileUC"), exports);
+__exportStar(require("./MockGetAssetUC"), exports);
+__exportStar(require("./MockUpdateAssetFileUC"), exports);

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

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

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppAssetListPM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const AppAssetsEntity_1 = require("../Entities/AppAssetsEntity");
+const AssetRepo_1 = require("../Entities/AssetRepo");
+class AppAssetListPM extends HostAppObject_1.HostAppObjectPM {
+    constructor(appObject) {
+        super(appObject, AppAssetListPM.type);
+        this.onAppAssetsChange = () => {
+            if (!this.appAssets)
+                return;
+            const allAppAssets = this.appAssets.getAll();
+            if (this.appAssets.showArchived) {
+                this.doUpdateView(allAppAssets);
+                return;
+            }
+            const nonArchivedAssets = [];
+            allAppAssets.forEach((assetID) => {
+                var _a;
+                const asset = (_a = this.assetRepo) === null || _a === void 0 ? void 0 : _a.get(assetID);
+                if (asset && asset.archived === false) {
+                    nonArchivedAssets.push(assetID);
+                }
+            });
+            this.doUpdateView(nonArchivedAssets);
+        };
+        this.appAssets = appObject.getComponent(AppAssetsEntity_1.AppAssetsEntity.type);
+        if (!this.appAssets) {
+            this.error('PM has been added to an app object without an AppAssetsEntity');
+            return;
+        }
+        this.appAssets.addChangeObserver(this.onAppAssetsChange);
+        this.appObjects.registerSingleton(this);
+        this.onAppAssetsChange();
+    }
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(AppAssetListPM.type, appObjects);
+    }
+    get assetRepo() {
+        return this.getCachedSingleton(AssetRepo_1.AssetRepo.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        let listsAreEqual = true;
+        a.forEach((aID, i) => {
+            const bID = b[i];
+            if (bID !== aID) {
+                listsAreEqual = false;
+            }
+        });
+        return listsAreEqual;
+    }
+}
+exports.AppAssetListPM = AppAssetListPM;
+AppAssetListPM.type = 'AppAssetListPM';

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

@@ -0,0 +1,16 @@
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
+export interface AssetVM {
+    id: string;
+    name: string;
+    description: string;
+    archived: boolean;
+}
+export declare class AssetPM extends HostAppObjectPM<AssetVM> {
+    static type: string;
+    static getByID(assetID: string, appObjects: HostAppObjectRepo): AssetPM | undefined;
+    private asset?;
+    vmsAreEqual(a: AssetVM, b: AssetVM): boolean;
+    private onAssetChange;
+    constructor(appObject: HostAppObject);
+}
+export declare const defaultAssetVM: AssetVM;