@vived/app 3.8.0 → 3.9.0

package/lib/AppObjectComponents/Dispatcher/UC/AppIsReadyUC.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appIsReady = exports.makeAppIsReadyUC = exports.AppIsReadyUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class AppIsReadyUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "APP_IS_READY";
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(AppIsReadyUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("AppIsReadyUC", `Unable to find component ${AppIsReadyUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("AppIsReadyUC", `Multiple ${AppIsReadyUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.AppIsReadyUC = AppIsReadyUC;
+AppIsReadyUC.type = "AppIsReadyUC";
+function makeAppIsReadyUC(appObject) {
+    return new AppIsReadyUCImp(appObject);
+}
+exports.makeAppIsReadyUC = makeAppIsReadyUC;
+function appIsReady(appObjects) {
+    const dispatchUC = AppIsReadyUC.get(appObjects);
+    if (dispatchUC) {
+        dispatchUC.doDispatch();
+    }
+    else {
+        App_1.submitWarning("appIsReady", "Can't find AppIsReadyUC", appObjects);
+    }
+}
+exports.appIsReady = appIsReady;
+class AppIsReadyUCImp extends AppIsReadyUC {
+    constructor(appObject) {
+        super(appObject, AppIsReadyUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            App_1.submitWarning("AppIsReadyUCImp", "AppIsReadyUCImp has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first", appObject.appObjectRepo);
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        if (!this.appDispatcher)
+            return;
+        this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion);
+    }
+}

package/lib/AppObjectComponents/Dispatcher/UC/DispatchStateChangeUC.d.ts

@@ -0,0 +1,18 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export interface DispatchStateChangePayload {
+    stateObject: object;
+    assets: string[];
+    validationErrorMessage?: string | undefined;
+}
+export declare abstract class DispatchStateChangeUC extends AppObjectUC {
+    static readonly type = "DispatchStateChangeUC";
+    readonly requestType = "ON_STATE_CHANGE";
+    abstract doDispatch(): void;
+    abstract validateState: () => string | undefined;
+    abstract getStateAssets: () => string[];
+    static get(appObjects: AppObjectRepo): DispatchStateChangeUC | undefined;
+}
+export declare function makeDispatchStateChangeUC(appObject: AppObject): DispatchStateChangeUC;
+export declare function dispatchStateChange(appObjects: AppObjectRepo): void;

package/lib/AppObjectComponents/Dispatcher/UC/DispatchStateChangeUC.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchStateChange = exports.makeDispatchStateChangeUC = exports.DispatchStateChangeUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const StateMachine_1 = require("../../StateMachine");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class DispatchStateChangeUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "ON_STATE_CHANGE";
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(DispatchStateChangeUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("DispatchStateChangeUC", `Unable to find component ${DispatchStateChangeUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("DispatchStateChangeUC", `Multiple ${DispatchStateChangeUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.DispatchStateChangeUC = DispatchStateChangeUC;
+DispatchStateChangeUC.type = "DispatchStateChangeUC";
+function makeDispatchStateChangeUC(appObject) {
+    return new DispatchStateChangeUCImp(appObject);
+}
+exports.makeDispatchStateChangeUC = makeDispatchStateChangeUC;
+function dispatchStateChange(appObjects) {
+    const dispatchUC = DispatchStateChangeUC.get(appObjects);
+    if (dispatchUC) {
+        dispatchUC.doDispatch();
+    }
+    else {
+        App_1.submitWarning("dispatchStateChange", "Can't find DispatchStateChangeUC", appObjects);
+    }
+}
+exports.dispatchStateChange = dispatchStateChange;
+class DispatchStateChangeUCImp extends DispatchStateChangeUC {
+    constructor(appObject) {
+        super(appObject, DispatchStateChangeUC.type);
+        this.requestVersion = 3;
+        this.validateState = () => {
+            return undefined;
+        };
+        this.getStateAssets = () => {
+            return [];
+        };
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            console.warn("DispatchStateChangeUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        var _a;
+        const stateMachine = StateMachine_1.StateMachineEntity.get(this.appObject.appObjectRepo);
+        if (!stateMachine) {
+            App_1.submitWarning("DispatchStateChangeUCImp", "Could not find StateMachineEntity", this.appObject.appObjectRepo);
+            return;
+        }
+        const baseApp = App_1.BaseAppState.get(this.appObject.appObjectRepo);
+        if (!baseApp) {
+            App_1.submitWarning("DispatchStateChangeUCImp", "Could not find BaseAppState", this.appObject.appObjectRepo);
+            return;
+        }
+        if (!baseApp.isAuthoring)
+            return;
+        const payload = {
+            stateObject: stateMachine.getSerializedStates(),
+            assets: this.getStateAssets(),
+            validationErrorMessage: this.validateState(),
+        };
+        (_a = this.appDispatcher) === null || _a === void 0 ? void 0 : _a.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+    }
+}

package/lib/AppObjectComponents/Dispatcher/UC/GetAssetBlobURLUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class GetAssetBlobURLUC extends AppObjectUC {
+    static readonly type = "GetAppAssetsURLUC";
+    readonly requestType = "GET_ASSET_BLOB";
+    abstract doDispatch(assetID: string): Promise<string>;
+    static get(appObjects: AppObjectRepo): GetAssetBlobURLUC | undefined;
+}
+export declare function makeGetAssetBlobURLUC(appObject: AppObject): GetAssetBlobURLUC;
+export declare function getAssetBlobURL(assetID: string, appObjects: AppObjectRepo): Promise<string>;

package/lib/AppObjectComponents/Dispatcher/UC/GetAssetBlobURLUC.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssetBlobURL = exports.makeGetAssetBlobURLUC = exports.GetAssetBlobURLUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class GetAssetBlobURLUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GET_ASSET_BLOB";
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(GetAssetBlobURLUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("GetAssetBlobURLUC", `Unable to find component ${GetAssetBlobURLUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("GetAssetBlobURLUC", `Multiple ${GetAssetBlobURLUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.GetAssetBlobURLUC = GetAssetBlobURLUC;
+GetAssetBlobURLUC.type = "GetAppAssetsURLUC";
+function makeGetAssetBlobURLUC(appObject) {
+    return new GetAppAssetsURLUCImp(appObject);
+}
+exports.makeGetAssetBlobURLUC = makeGetAssetBlobURLUC;
+function getAssetBlobURL(assetID, appObjects) {
+    const dispatchUC = GetAssetBlobURLUC.get(appObjects);
+    if (dispatchUC) {
+        return dispatchUC.doDispatch(assetID);
+    }
+    else {
+        App_1.submitWarning("getAssetBlobURL", "Can't find GetAssetBlobURLUC", appObjects);
+        return Promise.reject();
+    }
+}
+exports.getAssetBlobURL = getAssetBlobURL;
+class GetAppAssetsURLUCImp extends GetAssetBlobURLUC {
+    constructor(appObject) {
+        super(appObject, GetAssetBlobURLUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            App_1.submitWarning("GetAssetBlobURLUC", "GetAssetBlobURLUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first", appObject.appObjectRepo);
+            this.dispose();
+        }
+    }
+    doDispatch(assetID) {
+        return new Promise((resolve, reject) => {
+            const callback = (blobURL) => {
+                if (blobURL === undefined) {
+                    reject(new Error("Blob URL is undefined"));
+                }
+                else {
+                    resolve(blobURL);
+                }
+            };
+            const payload = {
+                assetID,
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}

package/lib/AppObjectComponents/Dispatcher/UC/GetAssetFolderURLUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class GetAssetFolderURLUC extends AppObjectUC {
+    static readonly type = "GetAssetFolderURLUC";
+    readonly requestType = "GET_APP_ASSET_URL";
+    abstract doDispatch(): Promise<string>;
+    static get(appObjects: AppObjectRepo): GetAssetFolderURLUC | undefined;
+}
+export declare function makeGetAssetFolderURLUC(appObject: AppObject): GetAssetFolderURLUC;
+export declare function getAssetFolderURL(appObjects: AppObjectRepo): Promise<string>;

package/lib/AppObjectComponents/Dispatcher/UC/GetAssetFolderURLUC.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssetFolderURL = exports.makeGetAssetFolderURLUC = exports.GetAssetFolderURLUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class GetAssetFolderURLUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GET_APP_ASSET_URL";
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(GetAssetFolderURLUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("GetAssetFolderURLUC", `Unable to find component ${GetAssetFolderURLUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("GetAssetFolderURLUC", `Multiple ${GetAssetFolderURLUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.GetAssetFolderURLUC = GetAssetFolderURLUC;
+GetAssetFolderURLUC.type = "GetAssetFolderURLUC";
+function makeGetAssetFolderURLUC(appObject) {
+    return new GetAppAssetsURLUCImp(appObject);
+}
+exports.makeGetAssetFolderURLUC = makeGetAssetFolderURLUC;
+function getAssetFolderURL(appObjects) {
+    const dispatchUC = GetAssetFolderURLUC.get(appObjects);
+    if (dispatchUC) {
+        return dispatchUC.doDispatch();
+    }
+    else {
+        App_1.submitWarning("getAssetFolderURL", "Can't find GetAppAssetsURLUC", appObjects);
+        return Promise.reject();
+    }
+}
+exports.getAssetFolderURL = getAssetFolderURL;
+class GetAppAssetsURLUCImp extends GetAssetFolderURLUC {
+    constructor(appObject) {
+        super(appObject, GetAssetFolderURLUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            App_1.submitWarning("GetAssetFolderURLUC", "GetAssetFolderURLUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first", appObject.appObjectRepo);
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        return new Promise((resolve, reject) => {
+            const callback = (url) => {
+                if (!url) {
+                    reject(new Error("URL to asset folder is empty"));
+                }
+                else {
+                    resolve(url);
+                }
+            };
+            const payload = {
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}

package/lib/AppObjectComponents/Dispatcher/UC/GetAssetMetaUC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { AssetMetaDTO } from "../../../Types";
+export declare abstract class GetAssetMetaUC extends AppObjectUC {
+    static readonly type = "GetAssetMetaUC";
+    readonly requestType = "GET_ASSET_META";
+    abstract doDispatch(assetID: string): Promise<AssetMetaDTO>;
+    static get(appObjects: AppObjectRepo): GetAssetMetaUC | undefined;
+}
+export declare function makeGetAssetMetaUC(appObject: AppObject): GetAssetMetaUC;
+export declare function getAssetMeta(assetID: string, appObjects: AppObjectRepo): Promise<AssetMetaDTO>;

package/lib/AppObjectComponents/Dispatcher/UC/GetAssetMetaUC.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssetMeta = exports.makeGetAssetMetaUC = exports.GetAssetMetaUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class GetAssetMetaUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GET_ASSET_META";
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(GetAssetMetaUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("GetAssetMetaUC", `Unable to find component ${GetAssetMetaUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("GetAssetMetaUC", `Multiple ${GetAssetMetaUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.GetAssetMetaUC = GetAssetMetaUC;
+GetAssetMetaUC.type = "GetAssetMetaUC";
+function makeGetAssetMetaUC(appObject) {
+    return new GetAppAssetsURLUCImp(appObject);
+}
+exports.makeGetAssetMetaUC = makeGetAssetMetaUC;
+function getAssetMeta(assetID, appObjects) {
+    const dispatchUC = GetAssetMetaUC.get(appObjects);
+    if (dispatchUC) {
+        return dispatchUC.doDispatch(assetID);
+    }
+    else {
+        App_1.submitWarning("getAssetBlobURL", "Can't find GetAssetMetaUC", appObjects);
+        return Promise.reject();
+    }
+}
+exports.getAssetMeta = getAssetMeta;
+class GetAppAssetsURLUCImp extends GetAssetMetaUC {
+    constructor(appObject) {
+        super(appObject, GetAssetMetaUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            App_1.submitWarning("GetAssetMetaUC", "GetAssetMetaUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first", appObject.appObjectRepo);
+            this.dispose();
+        }
+    }
+    doDispatch(assetID) {
+        return new Promise((resolve, reject) => {
+            const callback = (assetMeta) => {
+                if (assetMeta === undefined) {
+                    reject(new Error("Meta is undefined"));
+                }
+                else {
+                    resolve(assetMeta);
+                }
+            };
+            const payload = {
+                assetID,
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}

package/lib/AppObjectComponents/Dispatcher/UC/GetAssetsForOwnerUC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { AssetMetaDTO } from "../../../Types";
+export declare abstract class GetAssetsForOwnerUC extends AppObjectUC {
+    static readonly type = "GetAssetsForOwnerUC";
+    readonly requestType = "GET_ASSET_FOR_OWNER";
+    abstract doDispatch(ownerID: string): Promise<AssetMetaDTO[]>;
+    static get(appObjects: AppObjectRepo): GetAssetsForOwnerUC | undefined;
+}
+export declare function makeGetAssetsForOwnerUC(appObject: AppObject): GetAssetsForOwnerUC;
+export declare function getAssetsForOwner(ownerID: string, appObjects: AppObjectRepo): Promise<AssetMetaDTO[]>;

package/lib/AppObjectComponents/Dispatcher/UC/GetAssetsForOwnerUC.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssetsForOwner = exports.makeGetAssetsForOwnerUC = exports.GetAssetsForOwnerUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class GetAssetsForOwnerUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GET_ASSET_FOR_OWNER";
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(GetAssetsForOwnerUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("GetAssetsForOwnerUC", `Unable to find component ${GetAssetsForOwnerUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("GetAssetsForOwnerUC", `Multiple ${GetAssetsForOwnerUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.GetAssetsForOwnerUC = GetAssetsForOwnerUC;
+GetAssetsForOwnerUC.type = "GetAssetsForOwnerUC";
+function makeGetAssetsForOwnerUC(appObject) {
+    return new GetLinkedAssetsUCImp(appObject);
+}
+exports.makeGetAssetsForOwnerUC = makeGetAssetsForOwnerUC;
+function getAssetsForOwner(ownerID, appObjects) {
+    const dispatchUC = GetAssetsForOwnerUC.get(appObjects);
+    if (dispatchUC) {
+        return dispatchUC.doDispatch(ownerID);
+    }
+    else {
+        App_1.submitWarning("getAssetBlobURL", "Can't find GetAssetMetaUC", appObjects);
+        return Promise.reject();
+    }
+}
+exports.getAssetsForOwner = getAssetsForOwner;
+class GetLinkedAssetsUCImp extends GetAssetsForOwnerUC {
+    constructor(appObject) {
+        super(appObject, GetAssetsForOwnerUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            App_1.submitWarning("GetAssetsForOwnerUC", "GetAssetsForOwnerUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first", appObject.appObjectRepo);
+            this.dispose();
+        }
+    }
+    doDispatch(assetID) {
+        return new Promise((resolve, reject) => {
+            const callback = (ownerAssets) => {
+                if (ownerAssets === undefined) {
+                    reject(new Error("Owner asset list is missing"));
+                }
+                else {
+                    resolve(ownerAssets);
+                }
+            };
+            const payload = {
+                assetID,
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}

package/lib/AppObjectComponents/Dispatcher/UC/GetLinkedAssetsUC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { AssetMetaDTO } from "../../../Types";
+export declare abstract class GetLinkedAssetsUC extends AppObjectUC {
+    static readonly type = "GetLinkedAssetsUC";
+    readonly requestType = "GET_LINKED_ASSETS";
+    abstract doDispatch(assetID: string, type: string): Promise<AssetMetaDTO[]>;
+    static get(appObjects: AppObjectRepo): GetLinkedAssetsUC | undefined;
+}
+export declare function makeGetLinkedAssetsUC(appObject: AppObject): GetLinkedAssetsUC;
+export declare function getLinkedAssets(assetID: string, type: string, appObjects: AppObjectRepo): Promise<AssetMetaDTO[]>;

package/lib/AppObjectComponents/Dispatcher/UC/GetLinkedAssetsUC.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLinkedAssets = exports.makeGetLinkedAssetsUC = exports.GetLinkedAssetsUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class GetLinkedAssetsUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GET_LINKED_ASSETS";
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(GetLinkedAssetsUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("GetLinkedAssetsUC", `Unable to find component ${GetLinkedAssetsUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("GetLinkedAssetsUC", `Multiple ${GetLinkedAssetsUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.GetLinkedAssetsUC = GetLinkedAssetsUC;
+GetLinkedAssetsUC.type = "GetLinkedAssetsUC";
+function makeGetLinkedAssetsUC(appObject) {
+    return new GetLinkedAssetsUCImp(appObject);
+}
+exports.makeGetLinkedAssetsUC = makeGetLinkedAssetsUC;
+function getLinkedAssets(assetID, type, appObjects) {
+    const dispatchUC = GetLinkedAssetsUC.get(appObjects);
+    if (dispatchUC) {
+        return dispatchUC.doDispatch(assetID, type);
+    }
+    else {
+        App_1.submitWarning("getAssetBlobURL", "Can't find GetAssetMetaUC", appObjects);
+        return Promise.reject();
+    }
+}
+exports.getLinkedAssets = getLinkedAssets;
+class GetLinkedAssetsUCImp extends GetLinkedAssetsUC {
+    constructor(appObject) {
+        super(appObject, GetLinkedAssetsUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            App_1.submitWarning("GetLinkedAssetsUC", "GetLinkedAssetsUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first", appObject.appObjectRepo);
+            this.dispose();
+        }
+    }
+    doDispatch(assetID, type) {
+        return new Promise((resolve, reject) => {
+            const callback = (linkedAssets) => {
+                if (linkedAssets === undefined) {
+                    reject(new Error("Linked asset list is missing"));
+                }
+                else {
+                    resolve(linkedAssets);
+                }
+            };
+            const payload = {
+                assetID,
+                type,
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}

package/lib/AppObjectComponents/Dispatcher/UC/IsAssetFetchedUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class IsAssetFetchedUC extends AppObjectUC {
+    static readonly type = "IsAssetFetchedUC";
+    readonly requestType = "IS_ASSET_FILE_FETCHED";
+    abstract doDispatch(assetID: string): Promise<boolean>;
+    static get(appObjects: AppObjectRepo): IsAssetFetchedUC | undefined;
+}
+export declare function makeIsAssetFetchedUC(appObject: AppObject): IsAssetFetchedUC;
+export declare function isAssetFetched(assetID: string, appObjects: AppObjectRepo): Promise<boolean>;

package/lib/AppObjectComponents/Dispatcher/UC/IsAssetFetchedUC.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAssetFetched = exports.makeIsAssetFetchedUC = exports.IsAssetFetchedUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class IsAssetFetchedUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "IS_ASSET_FILE_FETCHED";
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(IsAssetFetchedUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("IsAssetFetchedUC", `Unable to find component ${IsAssetFetchedUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("IsAssetFetchedUC", `Multiple ${IsAssetFetchedUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.IsAssetFetchedUC = IsAssetFetchedUC;
+IsAssetFetchedUC.type = "IsAssetFetchedUC";
+function makeIsAssetFetchedUC(appObject) {
+    return new GetAppAssetsURLUCImp(appObject);
+}
+exports.makeIsAssetFetchedUC = makeIsAssetFetchedUC;
+function isAssetFetched(assetID, appObjects) {
+    const uc = IsAssetFetchedUC.get(appObjects);
+    if (uc) {
+        return uc.doDispatch(assetID);
+    }
+    else {
+        App_1.submitWarning("isAssetFetched", "Can't find IsAssetFetchedUC", appObjects);
+        return Promise.reject();
+    }
+}
+exports.isAssetFetched = isAssetFetched;
+class GetAppAssetsURLUCImp extends IsAssetFetchedUC {
+    constructor(appObject) {
+        super(appObject, IsAssetFetchedUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            App_1.submitWarning("IsAssetFetchedUC", "IsAssetFetchedUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first", appObject.appObjectRepo);
+            this.dispose();
+        }
+    }
+    doDispatch(assetID) {
+        return new Promise((resolve, reject) => {
+            const callback = (isFetched) => {
+                resolve(isFetched);
+            };
+            const payload = {
+                assetID,
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}