@vived/host 3.0.0

package/lib/Components/VivedAPI/Mocks/MockFetchAssetMetaUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockFetchAssetMetaUC = exports.MockFetchAssetMetaUC = void 0;
+const FetchAssetMetaFromAPIUC_1 = require("../UCs/FetchAssetMetaFromAPIUC");
+class MockFetchAssetMetaUC extends FetchAssetMetaFromAPIUC_1.FetchAssetMetaFromAPIUC {
+    constructor(appObject) {
+        super(appObject, FetchAssetMetaFromAPIUC_1.FetchAssetMetaFromAPIUC.type);
+        this.doFetch = jest.fn();
+    }
+}
+exports.MockFetchAssetMetaUC = MockFetchAssetMetaUC;
+function makeMockFetchAssetMetaUC(appObjects) {
+    return new MockFetchAssetMetaUC(appObjects.getOrCreate('MockFetchAssetMetaUC'));
+}
+exports.makeMockFetchAssetMetaUC = makeMockFetchAssetMetaUC;

package/lib/Components/VivedAPI/Mocks/MockFileUpload.d.ts

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

package/lib/Components/VivedAPI/Mocks/MockFileUpload.js

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

package/lib/Components/VivedAPI/Mocks/MockGetAppFromAPIUC.d.ts

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

package/lib/Components/VivedAPI/Mocks/MockGetAppFromAPIUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockGetAppFromAPIUC = exports.MockGetAppFromAPIUC = void 0;
+const GetAppFromAPIUC_1 = require("../UCs/GetAppFromAPIUC");
+class MockGetAppFromAPIUC extends GetAppFromAPIUC_1.GetAppFromAPIUC {
+    constructor(appObject) {
+        super(appObject, GetAppFromAPIUC_1.GetAppFromAPIUC.type);
+        this.getApp = jest.fn();
+    }
+}
+exports.MockGetAppFromAPIUC = MockGetAppFromAPIUC;
+function makeMockGetAppFromAPIUC(appObjects) {
+    return new MockGetAppFromAPIUC(appObjects.getOrCreate('MockGetAppFromAPIUC'));
+}
+exports.makeMockGetAppFromAPIUC = makeMockGetAppFromAPIUC;

package/lib/Components/VivedAPI/Mocks/MockGetAppUC.d.ts

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

package/lib/Components/VivedAPI/Mocks/MockGetAppUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockGetAppUC = exports.MockGetAppUC = void 0;
+const GetAppFromAPIUC_1 = require("../UCs/GetAppFromAPIUC");
+class MockGetAppUC extends GetAppFromAPIUC_1.GetAppFromAPIUC {
+    constructor(appObject) {
+        super(appObject, GetAppFromAPIUC_1.GetAppFromAPIUC.type);
+        this.getApp = jest.fn();
+    }
+}
+exports.MockGetAppUC = MockGetAppUC;
+function makeMockGetAppUC(appObjects) {
+    return new MockGetAppUC(appObjects.getOrCreate('MockGetAppUC'));
+}
+exports.makeMockGetAppUC = makeMockGetAppUC;

package/lib/Components/VivedAPI/Mocks/MockGetAssetsForOwnerUC.d.ts

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

package/lib/Components/VivedAPI/Mocks/MockGetAssetsForOwnerUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockGetAssetsForOwnerFromAPIUC = exports.MockGetAssetsForOwnerFromAPIUC = void 0;
+const GetAssetsForOwnerFromAPIUC_1 = require("../UCs/GetAssetsForOwnerFromAPIUC");
+class MockGetAssetsForOwnerFromAPIUC extends GetAssetsForOwnerFromAPIUC_1.GetAssetsForOwnerFromAPIUC {
+    constructor(appObject) {
+        super(appObject, GetAssetsForOwnerFromAPIUC_1.GetAssetsForOwnerFromAPIUC.type);
+        this.getAssets = jest.fn();
+    }
+}
+exports.MockGetAssetsForOwnerFromAPIUC = MockGetAssetsForOwnerFromAPIUC;
+function makeMockGetAssetsForOwnerFromAPIUC(appObjects) {
+    return new MockGetAssetsForOwnerFromAPIUC(appObjects.getOrCreate('MockGetAssetsForOwnerFromAPIUC'));
+}
+exports.makeMockGetAssetsForOwnerFromAPIUC = makeMockGetAssetsForOwnerFromAPIUC;

package/lib/Components/VivedAPI/Mocks/MockJsonRequestUC.d.ts

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

package/lib/Components/VivedAPI/Mocks/MockJsonRequestUC.js

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

package/lib/Components/VivedAPI/Mocks/MockPatchAssetFileUC.d.ts

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

package/lib/Components/VivedAPI/Mocks/MockPatchAssetFileUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockMockPatchAssetFileUC = exports.MockPatchAssetFileUC = void 0;
+const PatchAssetFileUC_1 = require("../UCs/PatchAssetFileUC");
+class MockPatchAssetFileUC extends PatchAssetFileUC_1.PatchAssetFileUC {
+    constructor(appObject) {
+        super(appObject, PatchAssetFileUC_1.PatchAssetFileUC.type);
+        this.doPatch = jest.fn().mockResolvedValue('new.filename');
+    }
+}
+exports.MockPatchAssetFileUC = MockPatchAssetFileUC;
+function mockMockPatchAssetFileUC(appObjects) {
+    return new MockPatchAssetFileUC(appObjects.getOrCreate('MockPatchAssetFileUC'));
+}
+exports.mockMockPatchAssetFileUC = mockMockPatchAssetFileUC;

package/lib/Components/VivedAPI/Mocks/MockPatchAssetIsArchivedUC.d.ts

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

package/lib/Components/VivedAPI/Mocks/MockPatchAssetIsArchivedUC.js

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

package/lib/Components/VivedAPI/Mocks/MockPatchAssetMetaUC.d.ts

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

package/lib/Components/VivedAPI/Mocks/MockPatchAssetMetaUC.js

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

package/lib/Components/VivedAPI/Mocks/MockPatchAssetUC.d.ts

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

package/lib/Components/VivedAPI/Mocks/MockPatchAssetUC.js

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

package/lib/Components/VivedAPI/Mocks/MockPostNewAssetUC.d.ts

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

package/lib/Components/VivedAPI/Mocks/MockPostNewAssetUC.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockPostNewAssetUC = exports.MockPostNewAssetUC = void 0;
+const PostNewAssetUC_1 = require("../UCs/PostNewAssetUC");
+class MockPostNewAssetUC extends PostNewAssetUC_1.PostNewAssetUC {
+    constructor(appObject) {
+        super(appObject, PostNewAssetUC_1.PostNewAssetUC.type);
+        this.doPost = jest.fn().mockResolvedValue({
+            id: 'newAssetID',
+            filename: 'newAssetFile.name',
+        });
+    }
+}
+exports.MockPostNewAssetUC = MockPostNewAssetUC;
+function makeMockPostNewAssetUC(appObjects) {
+    return new MockPostNewAssetUC(appObjects.getOrCreate('MockPostNewAssetUC'));
+}
+exports.makeMockPostNewAssetUC = makeMockPostNewAssetUC;

package/lib/Components/VivedAPI/Mocks/MockSignedAuthToken.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { SignedAuthTokenUC } from "../UCs/SignedAuthTokenUC";
+export declare class MockSignedAuthTokenUC extends SignedAuthTokenUC {
+    getPlayerAuthToken: jest.Mock<any, any>;
+    getUserAuthToken: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockSignedAuthTokenUC(appObjects: HostAppObjectRepo): MockSignedAuthTokenUC;

package/lib/Components/VivedAPI/Mocks/MockSignedAuthToken.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockSignedAuthTokenUC = exports.MockSignedAuthTokenUC = void 0;
+const SignedAuthTokenUC_1 = require("../UCs/SignedAuthTokenUC");
+class MockSignedAuthTokenUC extends SignedAuthTokenUC_1.SignedAuthTokenUC {
+    constructor(appObject) {
+        super(appObject, SignedAuthTokenUC_1.SignedAuthTokenUC.type);
+        this.getPlayerAuthToken = jest.fn();
+        this.getUserAuthToken = jest.fn();
+    }
+}
+exports.MockSignedAuthTokenUC = MockSignedAuthTokenUC;
+function makeMockSignedAuthTokenUC(appObjects) {
+    return new MockSignedAuthTokenUC(appObjects.getOrCreate("MockSignedAuthTokenUC"));
+}
+exports.makeMockSignedAuthTokenUC = makeMockSignedAuthTokenUC;

package/lib/Components/VivedAPI/Mocks/MockUserLoginUC.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from '../../../HostAppObject';
+import { UserAuthUC } from '../UCs/UserAuthUC';
+export declare class MockUserAuthUC extends UserAuthUC {
+    login: jest.Mock<any, any>;
+    logout: jest.Mock<any, any>;
+    refreshAuthenticatedUser: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockUserLoginUC(appObjects: HostAppObjectRepo): MockUserAuthUC;

package/lib/Components/VivedAPI/Mocks/MockUserLoginUC.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockUserLoginUC = exports.MockUserAuthUC = void 0;
+const UserAuthUC_1 = require("../UCs/UserAuthUC");
+class MockUserAuthUC extends UserAuthUC_1.UserAuthUC {
+    constructor(appObject) {
+        super(appObject, UserAuthUC_1.UserAuthUC.type);
+        this.login = jest.fn().mockResolvedValue(undefined);
+        this.logout = jest.fn().mockResolvedValue(undefined);
+        this.refreshAuthenticatedUser = jest.fn().mockResolvedValue(undefined);
+    }
+}
+exports.MockUserAuthUC = MockUserAuthUC;
+function makeMockUserLoginUC(appObjects) {
+    return new MockUserAuthUC(appObjects.getOrCreate('MockUserAuthUC'));
+}
+exports.makeMockUserLoginUC = makeMockUserLoginUC;

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

@@ -0,0 +1,16 @@
+export * from './MockBasicFetchUC';
+export * from './MockBlobRequestUC';
+export * from './MockDeleteAssetOnAPIUC';
+export * from './MockFetchAssetFileFromAPIUC';
+export * from './MockFetchAssetMetaFromAPIUC';
+export * from './MockFileUpload';
+export * from './MockGetAppFromAPIUC';
+export * from './MockGetAssetsForOwnerUC';
+export * from './MockJsonRequestUC';
+export * from './MockPatchAssetFileUC';
+export * from './MockPatchAssetIsArchivedUC';
+export * from './MockPatchAssetMetaUC';
+export * from './MockPatchAssetUC';
+export * from './MockPostNewAssetUC';
+export * from './MockSignedAuthToken';
+export * from './MockUserLoginUC';

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

@@ -0,0 +1,28 @@
+"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("./MockBasicFetchUC"), exports);
+__exportStar(require("./MockBlobRequestUC"), exports);
+__exportStar(require("./MockDeleteAssetOnAPIUC"), exports);
+__exportStar(require("./MockFetchAssetFileFromAPIUC"), exports);
+__exportStar(require("./MockFetchAssetMetaFromAPIUC"), exports);
+__exportStar(require("./MockFileUpload"), exports);
+__exportStar(require("./MockGetAppFromAPIUC"), exports);
+__exportStar(require("./MockGetAssetsForOwnerUC"), exports);
+__exportStar(require("./MockJsonRequestUC"), exports);
+__exportStar(require("./MockPatchAssetFileUC"), exports);
+__exportStar(require("./MockPatchAssetIsArchivedUC"), exports);
+__exportStar(require("./MockPatchAssetMetaUC"), exports);
+__exportStar(require("./MockPatchAssetUC"), exports);
+__exportStar(require("./MockPostNewAssetUC"), exports);
+__exportStar(require("./MockSignedAuthToken"), exports);
+__exportStar(require("./MockUserLoginUC"), exports);

package/lib/Components/VivedAPI/PMs/UserTokenPM.d.ts

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

package/lib/Components/VivedAPI/PMs/UserTokenPM.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserTokenPM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class UserTokenPM extends HostAppObject_1.HostAppObjectPM {
+    constructor(appObject) {
+        super(appObject, UserTokenPM.type);
+        this.onEntityChange = () => {
+            if (!this.vivedAPI)
+                return;
+            this.doUpdateView(this.vivedAPI.userToken);
+        };
+        this.vivedAPI = appObject.getComponent(Entities_1.VivedAPIEntity.type);
+        if (!this.vivedAPI) {
+            this.error('PM has been added to an App Object that does not have a VivedAPIEntity');
+            return;
+        }
+        this.vivedAPI.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+        this.appObjects.registerSingleton(this);
+    }
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(UserTokenPM.type, appObjects);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}
+exports.UserTokenPM = UserTokenPM;
+UserTokenPM.type = 'UserTokenPM';

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

@@ -0,0 +1 @@
+export * from "./UserTokenPM";

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

@@ -0,0 +1,13 @@
+"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("./UserTokenPM"), exports);

package/lib/Components/VivedAPI/UCs/BasicFetchUC.d.ts

@@ -0,0 +1,13 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export interface BasicFetchOptions {
+    headers?: any;
+    method: "GET" | "PATCH" | "POST" | "PUT" | "DELETE" | undefined;
+    params?: any;
+    body?: any;
+}
+export declare abstract class BasicFetchUC extends HostAppObjectUC {
+    static type: string;
+    abstract doRequest(url: URL, options?: BasicFetchOptions): Promise<Response>;
+    static get(appObjects: HostAppObjectRepo): BasicFetchUC | undefined;
+}
+export declare function makeBasicFetchUC(appObject: HostAppObject): BasicFetchUC;

package/lib/Components/VivedAPI/UCs/BasicFetchUC.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBasicFetchUC = exports.BasicFetchUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+class BasicFetchUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(BasicFetchUC.type, appObjects);
+    }
+}
+exports.BasicFetchUC = BasicFetchUC;
+BasicFetchUC.type = "BasicFetchUC";
+function makeBasicFetchUC(appObject) {
+    return new BasicFetchUCImp(appObject);
+}
+exports.makeBasicFetchUC = makeBasicFetchUC;
+class BasicFetchUCImp extends BasicFetchUC {
+    constructor(appObject) {
+        super(appObject, BasicFetchUC.type);
+        this.doRequest = (url, options) => {
+            return new Promise((resolve, reject) => {
+                fetch(url.href, options)
+                    .then((resp) => {
+                    if (!resp.ok) {
+                        reject(new Error(`Response is not OK: ${resp}`));
+                    }
+                    resolve(resp);
+                })
+                    .catch((e) => {
+                    reject(e);
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+}

package/lib/Components/VivedAPI/UCs/BlobRequestUC.d.ts

@@ -0,0 +1,13 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export interface RequestBlobOptions {
+    headers?: any;
+    method: "GET" | "PATCH" | "POST" | "PUT" | "DELETE" | undefined;
+    params?: any;
+    body?: any;
+}
+export declare abstract class BlobRequestUC extends HostAppObjectUC {
+    static type: string;
+    abstract doRequest(url: URL, options?: RequestBlobOptions): Promise<Blob>;
+    static get(appObjects: HostAppObjectRepo): BlobRequestUC | undefined;
+}
+export declare function makeBlobRequestUC(appObject: HostAppObject): BlobRequestUC;

package/lib/Components/VivedAPI/UCs/BlobRequestUC.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBlobRequestUC = exports.BlobRequestUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+class BlobRequestUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(BlobRequestUC.type, appObjects);
+    }
+}
+exports.BlobRequestUC = BlobRequestUC;
+BlobRequestUC.type = "BlobRequestUC";
+function makeBlobRequestUC(appObject) {
+    return new BlobRequestUCImp(appObject);
+}
+exports.makeBlobRequestUC = makeBlobRequestUC;
+class BlobRequestUCImp extends BlobRequestUC {
+    constructor(appObject) {
+        super(appObject, BlobRequestUC.type);
+        this.doRequest = (url, options) => {
+            return new Promise((resolve, reject) => {
+                fetch(url.href, options)
+                    .then((resp) => {
+                    if (!resp.ok) {
+                        reject(new Error(`Response is not OK: ${JSON.stringify(resp)}`));
+                    }
+                    return resp.blob();
+                })
+                    .then((blob) => {
+                    resolve(blob);
+                })
+                    .catch((e) => {
+                    reject(e);
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+}

package/lib/Components/VivedAPI/UCs/DeleteAssetOnAPIUC.d.ts

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

package/lib/Components/VivedAPI/UCs/DeleteAssetOnAPIUC.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDeleteAssetOnAPIUC = exports.DeleteAssetOnAPIUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+const SignedAuthTokenUC_1 = require("./SignedAuthTokenUC");
+class DeleteAssetOnAPIUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(DeleteAssetOnAPIUC.type, appObjects);
+    }
+}
+exports.DeleteAssetOnAPIUC = DeleteAssetOnAPIUC;
+DeleteAssetOnAPIUC.type = 'DeleteAssetOnAPIUC';
+function makeDeleteAssetOnAPIUC(appObject) {
+    return new DeleteAssetUCImp(appObject);
+}
+exports.makeDeleteAssetOnAPIUC = makeDeleteAssetOnAPIUC;
+class DeleteAssetUCImp extends DeleteAssetOnAPIUC {
+    constructor(appObject) {
+        super(appObject, DeleteAssetOnAPIUC.type);
+        this.doDelete = (assetID) => {
+            const getAuthToken = this.getAuthToken;
+            const vivedAPI = this.vivedAPI;
+            const jsonRequester = this.jsonRequester;
+            if (!getAuthToken || !vivedAPI || !jsonRequester) {
+                return Promise.reject();
+            }
+            return new Promise((resolve, reject) => {
+                getAuthToken()
+                    .then((token) => {
+                    const postURL = vivedAPI.getEndpointURL(`assets/${assetID}`);
+                    const options = {
+                        method: 'DELETE',
+                        headers: {
+                            Authorization: 'Bearer ' + token,
+                        },
+                    };
+                    return jsonRequester(postURL, options);
+                })
+                    .then((_) => {
+                    resolve();
+                })
+                    .catch((e) => {
+                    reject(e);
+                    return;
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get jsonRequester() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get getAuthToken() {
+        var _a;
+        return (_a = this.getCachedSingleton(SignedAuthTokenUC_1.SignedAuthTokenUC.type)) === null || _a === void 0 ? void 0 : _a.getUserAuthToken;
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+}

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

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