@vived/host 3.0.0

package/lib/Components/Dispatcher/Mocks/MockDispatchAppDispatcherUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDispatchDisposeAppUC = void 0;
+const UCs_1 = require("../UCs");
+class MockDispatchDisposeAppUC extends UCs_1.DispatchDisposeAppUC {
+    constructor(appObject) {
+        super(appObject, UCs_1.DispatchDisposeAppUC.type);
+        this.doDispatch = jest.fn();
+    }
+}
+exports.MockDispatchDisposeAppUC = MockDispatchDisposeAppUC;

package/lib/Components/Dispatcher/Mocks/MockDispatchIsAuthoringUC.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { DispatchIsAuthoringUC } from "../UCs";
+export declare class MockDispatchIsAuthoringUC extends DispatchIsAuthoringUC {
+    doDispatch: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dispatcher/Mocks/MockDispatchIsAuthoringUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDispatchIsAuthoringUC = void 0;
+const UCs_1 = require("../UCs");
+class MockDispatchIsAuthoringUC extends UCs_1.DispatchIsAuthoringUC {
+    constructor(appObject) {
+        super(appObject, UCs_1.DispatchIsAuthoringUC.type);
+        this.doDispatch = jest.fn();
+    }
+}
+exports.MockDispatchIsAuthoringUC = MockDispatchIsAuthoringUC;

package/lib/Components/Dispatcher/Mocks/MockDispatchSetStateUC.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { DispatchSetStateUC } from "../UCs";
+export declare class MockDispatchSetStateUC extends DispatchSetStateUC {
+    doDispatch: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dispatcher/Mocks/MockDispatchSetStateUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDispatchSetStateUC = void 0;
+const UCs_1 = require("../UCs");
+class MockDispatchSetStateUC extends UCs_1.DispatchSetStateUC {
+    constructor(appObject) {
+        super(appObject, UCs_1.DispatchSetStateUC.type);
+        this.doDispatch = jest.fn();
+    }
+}
+exports.MockDispatchSetStateUC = MockDispatchSetStateUC;

package/lib/Components/Dispatcher/Mocks/MockDispatchShowBabylonInspectorUC.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { DispatchShowBabylonInspectorUC } from "../UCs";
+export declare class MockDispatchShowBabylonInspectorUC extends DispatchShowBabylonInspectorUC {
+    doDispatch: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dispatcher/Mocks/MockDispatchShowBabylonInspectorUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDispatchShowBabylonInspectorUC = void 0;
+const UCs_1 = require("../UCs");
+class MockDispatchShowBabylonInspectorUC extends UCs_1.DispatchShowBabylonInspectorUC {
+    constructor(appObject) {
+        super(appObject, UCs_1.DispatchShowBabylonInspectorUC.type);
+        this.doDispatch = jest.fn();
+    }
+}
+exports.MockDispatchShowBabylonInspectorUC = MockDispatchShowBabylonInspectorUC;

package/lib/Components/Dispatcher/Mocks/MockDispatchStartAppUC.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { DispatchStartAppUC } from "../UCs";
+export declare class MockDispatchStartAppUC extends DispatchStartAppUC {
+    doDispatch: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dispatcher/Mocks/MockDispatchStartAppUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDispatchStartAppUC = void 0;
+const UCs_1 = require("../UCs");
+class MockDispatchStartAppUC extends UCs_1.DispatchStartAppUC {
+    constructor(appObject) {
+        super(appObject, UCs_1.DispatchStartAppUC.type);
+        this.doDispatch = jest.fn();
+    }
+}
+exports.MockDispatchStartAppUC = MockDispatchStartAppUC;

package/lib/Components/Dispatcher/Mocks/MockDispatchStartBrowseChannelsUC.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { DispatchStartBrowseChannelsUC } from "../UCs/DispatchStartBrowseChannelsUC";
+export declare class MockDispatchStartBrowseChannelsUC extends DispatchStartBrowseChannelsUC {
+    doDispatch: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dispatcher/Mocks/MockDispatchStartBrowseChannelsUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDispatchStartBrowseChannelsUC = void 0;
+const DispatchStartBrowseChannelsUC_1 = require("../UCs/DispatchStartBrowseChannelsUC");
+class MockDispatchStartBrowseChannelsUC extends DispatchStartBrowseChannelsUC_1.DispatchStartBrowseChannelsUC {
+    constructor(appObject) {
+        super(appObject, DispatchStartBrowseChannelsUC_1.DispatchStartBrowseChannelsUC.type);
+        this.doDispatch = jest.fn();
+    }
+}
+exports.MockDispatchStartBrowseChannelsUC = MockDispatchStartBrowseChannelsUC;

package/lib/Components/Dispatcher/Mocks/MockDispatchStartZSpaceUC.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { DispatchStartZSpaceUC } from "../UCs";
+export declare class MockDispatchStartZSpaceUC extends DispatchStartZSpaceUC {
+    doDispatch: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dispatcher/Mocks/MockDispatchStartZSpaceUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDispatchStartZSpaceUC = void 0;
+const UCs_1 = require("../UCs");
+class MockDispatchStartZSpaceUC extends UCs_1.DispatchStartZSpaceUC {
+    constructor(appObject) {
+        super(appObject, UCs_1.DispatchStartZSpaceUC.type);
+        this.doDispatch = jest.fn();
+    }
+}
+exports.MockDispatchStartZSpaceUC = MockDispatchStartZSpaceUC;

package/lib/Components/Dispatcher/Mocks/MockDispatchStopAppUC.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { DispatchStopAppUC } from "../UCs";
+export declare class MockDispatchStopAppUC extends DispatchStopAppUC {
+    doDispatch: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dispatcher/Mocks/MockDispatchStopAppUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDispatchStopAppUC = void 0;
+const UCs_1 = require("../UCs");
+class MockDispatchStopAppUC extends UCs_1.DispatchStopAppUC {
+    constructor(appObject) {
+        super(appObject, UCs_1.DispatchStopAppUC.type);
+        this.doDispatch = jest.fn();
+    }
+}
+exports.MockDispatchStopAppUC = MockDispatchStopAppUC;

package/lib/Components/Dispatcher/Mocks/MockDispatchStopZSpaceUC.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { DispatchStopZSpaceUC } from "../UCs";
+export declare class MockDispatchStopZSpaceUC extends DispatchStopZSpaceUC {
+    doDispatch: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dispatcher/Mocks/MockDispatchStopZSpaceUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDispatchStopZSpaceUC = void 0;
+const UCs_1 = require("../UCs");
+class MockDispatchStopZSpaceUC extends UCs_1.DispatchStopZSpaceUC {
+    constructor(appObject) {
+        super(appObject, UCs_1.DispatchStopZSpaceUC.type);
+        this.doDispatch = jest.fn();
+    }
+}
+exports.MockDispatchStopZSpaceUC = MockDispatchStopZSpaceUC;

package/lib/Components/Dispatcher/Mocks/MockDispatchThemeUC.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { DispatchThemeUC } from "../UCs";
+export declare class MockDispatchThemeUC extends DispatchThemeUC {
+    doDispatch: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dispatcher/Mocks/MockDispatchThemeUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDispatchThemeUC = void 0;
+const UCs_1 = require("../UCs");
+class MockDispatchThemeUC extends UCs_1.DispatchThemeUC {
+    constructor(appObject) {
+        super(appObject, UCs_1.DispatchThemeUC.type);
+        this.doDispatch = jest.fn();
+    }
+}
+exports.MockDispatchThemeUC = MockDispatchThemeUC;

package/lib/Components/Dispatcher/Mocks/MockHostDispatcher.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { HostDispatchEntity } from "../Entities";
+export declare class MockHostDispatchEntity extends HostDispatchEntity {
+    appHandlerVersion: number;
+    getRequestPayloadVersion: jest.Mock<any, any>;
+    registerAppHandler: jest.Mock<any, any>;
+    dispatch: jest.Mock<any, any>;
+    formRequestAndDispatch: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dispatcher/Mocks/MockHostDispatcher.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockHostDispatchEntity = void 0;
+const Entities_1 = require("../Entities");
+class MockHostDispatchEntity extends Entities_1.HostDispatchEntity {
+    constructor(appObject) {
+        super(appObject, Entities_1.HostDispatchEntity.type);
+        this.appHandlerVersion = 1;
+        this.getRequestPayloadVersion = jest.fn();
+        this.registerAppHandler = jest.fn();
+        this.dispatch = jest.fn();
+        this.formRequestAndDispatch = jest.fn();
+    }
+}
+exports.MockHostDispatchEntity = MockHostDispatchEntity;

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

@@ -0,0 +1,11 @@
+export * from "./MockDispatchAppDispatcherUC";
+export * from "./MockDispatchIsAuthoringUC";
+export * from "./MockDispatchSetStateUC";
+export * from "./MockDispatchShowBabylonInspectorUC";
+export * from "./MockDispatchStartAppUC";
+export * from "./MockDispatchStartBrowseChannelsUC";
+export * from "./MockDispatchStartZSpaceUC";
+export * from "./MockDispatchStopAppUC";
+export * from "./MockDispatchStopZSpaceUC";
+export * from "./MockDispatchThemeUC";
+export * from "./MockHostDispatcher";

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

@@ -0,0 +1,23 @@
+"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("./MockDispatchAppDispatcherUC"), exports);
+__exportStar(require("./MockDispatchIsAuthoringUC"), exports);
+__exportStar(require("./MockDispatchSetStateUC"), exports);
+__exportStar(require("./MockDispatchShowBabylonInspectorUC"), exports);
+__exportStar(require("./MockDispatchStartAppUC"), exports);
+__exportStar(require("./MockDispatchStartBrowseChannelsUC"), exports);
+__exportStar(require("./MockDispatchStartZSpaceUC"), exports);
+__exportStar(require("./MockDispatchStopAppUC"), exports);
+__exportStar(require("./MockDispatchStopZSpaceUC"), exports);
+__exportStar(require("./MockDispatchThemeUC"), exports);
+__exportStar(require("./MockHostDispatcher"), exports);

package/lib/Components/Dispatcher/UCs/DispatchDisposeAppUC.d.ts

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class DispatchDisposeAppUC extends HostAppObjectUC {
+    static readonly type = "DispatchDisposeAppUC";
+    readonly requestType = "DISPOSE_APP";
+    abstract doDispatch(): void;
+    static get(appObject: HostAppObject): DispatchDisposeAppUC | undefined;
+    static getByID(id: string, appObjects: HostAppObjectRepo): DispatchDisposeAppUC | undefined;
+}
+export declare function makeDispatchDisposeAppUC(appObject: HostAppObject): DispatchDisposeAppUC;

package/lib/Components/Dispatcher/UCs/DispatchDisposeAppUC.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDispatchDisposeAppUC = exports.DispatchDisposeAppUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class DispatchDisposeAppUC extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "DISPOSE_APP";
+    }
+    static get(appObject) {
+        const asset = appObject.getComponent(DispatchDisposeAppUC.type);
+        if (!asset) {
+            appObject.appObjectRepo.submitWarning("DispatchAppDispatcherUC.get", "Unable to find DispatchAppDispatcherUC on app object " + appObject.id);
+        }
+        return asset;
+    }
+    static getByID(id, appObjects) {
+        const appObject = appObjects.get(id);
+        if (!appObject) {
+            appObjects.submitWarning("DispatchDisposeAppUC.getByID", "Unable to find App Object by id " + id);
+            return undefined;
+        }
+        return DispatchDisposeAppUC.get(appObject);
+    }
+}
+exports.DispatchDisposeAppUC = DispatchDisposeAppUC;
+DispatchDisposeAppUC.type = "DispatchDisposeAppUC";
+function makeDispatchDisposeAppUC(appObject) {
+    return new DispatchDisposeAppUCImp(appObject);
+}
+exports.makeDispatchDisposeAppUC = makeDispatchDisposeAppUC;
+class DispatchDisposeAppUCImp extends DispatchDisposeAppUC {
+    constructor(appObject) {
+        super(appObject, DispatchDisposeAppUC.type);
+        this.requestVersion = 1;
+        this.dispatcher = appObject.getComponent(Entities_1.HostDispatchEntity.type);
+        if (!this.dispatcher) {
+            this.error("UC has been added to an App Object that does not have a HostDispatchEntity. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        if (!this.dispatcher)
+            return;
+        this.dispatcher.formRequestAndDispatch(this.requestType, this.requestVersion);
+    }
+}

package/lib/Components/Dispatcher/UCs/DispatchIsAuthoringUC.d.ts

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class DispatchIsAuthoringUC extends HostAppObjectUC {
+    static readonly type = "DispatchIsAuthoringUC";
+    readonly requestType = "SET_IS_AUTHORING";
+    abstract doDispatch(isAuthoring: boolean): void;
+    static get(appObject: HostAppObject): DispatchIsAuthoringUC | undefined;
+    static getByID(id: string, appObjects: HostAppObjectRepo): DispatchIsAuthoringUC | undefined;
+}
+export declare function makeDispatchIsAuthoringUC(appObject: HostAppObject): DispatchIsAuthoringUC;

package/lib/Components/Dispatcher/UCs/DispatchIsAuthoringUC.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDispatchIsAuthoringUC = exports.DispatchIsAuthoringUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class DispatchIsAuthoringUC extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SET_IS_AUTHORING";
+    }
+    static get(appObject) {
+        const asset = appObject.getComponent(DispatchIsAuthoringUC.type);
+        if (!asset) {
+            appObject.appObjectRepo.submitWarning("DispatchIsAuthoringUC.get", "Unable to find DispatchIsAuthoringUC on app object " +
+                appObject.id);
+        }
+        return asset;
+    }
+    static getByID(id, appObjects) {
+        const appObject = appObjects.get(id);
+        if (!appObject) {
+            appObjects.submitWarning("DispatchIsAuthoringUC.getByID", "Unable to find App Object by id " + id);
+            return undefined;
+        }
+        return DispatchIsAuthoringUC.get(appObject);
+    }
+}
+exports.DispatchIsAuthoringUC = DispatchIsAuthoringUC;
+DispatchIsAuthoringUC.type = "DispatchIsAuthoringUC";
+function makeDispatchIsAuthoringUC(appObject) {
+    return new DispatchIsAuthoringUCImp(appObject);
+}
+exports.makeDispatchIsAuthoringUC = makeDispatchIsAuthoringUC;
+class DispatchIsAuthoringUCImp extends DispatchIsAuthoringUC {
+    constructor(appObject) {
+        super(appObject, DispatchIsAuthoringUC.type);
+        this.requestVersion = 1;
+        this.dispatcher = appObject.getComponent(Entities_1.HostDispatchEntity.type);
+        if (!this.dispatcher) {
+            this.error("UC has been added to an App Object that does not have a HostDispatchEntity. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch(isAuthoring) {
+        if (!this.dispatcher)
+            return;
+        const payload = {
+            isAuthoring
+        };
+        this.dispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+    }
+}

package/lib/Components/Dispatcher/UCs/DispatchSetStateUC.d.ts

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class DispatchSetStateUC extends HostAppObjectUC {
+    static readonly type = "DispatchSetStateUC";
+    readonly requestType = "SET_APP_STATE";
+    abstract doDispatch(finalState: string, duration?: number | undefined): void;
+    static get(appObject: HostAppObject): DispatchSetStateUC | undefined;
+    static getByID(id: string, appObjects: HostAppObjectRepo): DispatchSetStateUC | undefined;
+}
+export declare function makeDispatchSetStateUC(appObject: HostAppObject): DispatchSetStateUC;

package/lib/Components/Dispatcher/UCs/DispatchSetStateUC.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDispatchSetStateUC = exports.DispatchSetStateUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class DispatchSetStateUC extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SET_APP_STATE";
+    }
+    static get(appObject) {
+        const asset = appObject.getComponent(DispatchSetStateUC.type);
+        if (!asset) {
+            appObject.appObjectRepo.submitWarning("DispatchSetStateUC.get", "Unable to find DispatchSetStateUC on app object " + appObject.id);
+        }
+        return asset;
+    }
+    static getByID(id, appObjects) {
+        const appObject = appObjects.get(id);
+        if (!appObject) {
+            appObjects.submitWarning("DispatchSetStateUC.getByID", "Unable to find App Object by id " + id);
+            return undefined;
+        }
+        return DispatchSetStateUC.get(appObject);
+    }
+}
+exports.DispatchSetStateUC = DispatchSetStateUC;
+DispatchSetStateUC.type = "DispatchSetStateUC";
+function makeDispatchSetStateUC(appObject) {
+    return new DispatchSetStateUCImp(appObject);
+}
+exports.makeDispatchSetStateUC = makeDispatchSetStateUC;
+class DispatchSetStateUCImp extends DispatchSetStateUC {
+    constructor(appObject) {
+        super(appObject, DispatchSetStateUC.type);
+        this.requestVersion = 2;
+        this.dispatcher = appObject.getComponent(Entities_1.HostDispatchEntity.type);
+        if (!this.dispatcher) {
+            this.error("UC has been added to an App Object that does not have a HostDispatchEntity. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch(finalState, duration) {
+        if (!this.dispatcher)
+            return;
+        const payload = {
+            finalState,
+            duration
+        };
+        this.dispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+    }
+}

package/lib/Components/Dispatcher/UCs/DispatchShowBabylonInspectorUC.d.ts

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from '../../../HostAppObject';
+export declare abstract class DispatchShowBabylonInspectorUC extends HostAppObjectUC {
+    static readonly type = "DispatchShowBabylonInspectorUC";
+    readonly requestType = "SHOW_BABYLON_INSPECTOR";
+    abstract doDispatch(show: boolean): void;
+    static get(appObject: HostAppObject): DispatchShowBabylonInspectorUC | undefined;
+    static getByID(id: string, appObjects: HostAppObjectRepo): DispatchShowBabylonInspectorUC | undefined;
+}
+export declare function makeDispatchShowBabylonInspectorUC(appObject: HostAppObject): DispatchShowBabylonInspectorUC;

package/lib/Components/Dispatcher/UCs/DispatchShowBabylonInspectorUC.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDispatchShowBabylonInspectorUC = exports.DispatchShowBabylonInspectorUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class DispatchShowBabylonInspectorUC extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = 'SHOW_BABYLON_INSPECTOR';
+    }
+    static get(appObject) {
+        const asset = appObject.getComponent(DispatchShowBabylonInspectorUC.type);
+        if (!asset) {
+            appObject.appObjectRepo.submitWarning('DispatchShowBabylonInspectorUC.get', 'Unable to find DispatchShowBabylonInspectorUC on app object ' + appObject.id);
+        }
+        return asset;
+    }
+    static getByID(id, appObjects) {
+        const appObject = appObjects.get(id);
+        if (!appObject) {
+            appObjects.submitWarning("DispatchShowBabylonInspectorUC.getByID", "Unable to find App Object by id " + id);
+            return undefined;
+        }
+        return DispatchShowBabylonInspectorUC.get(appObject);
+    }
+}
+exports.DispatchShowBabylonInspectorUC = DispatchShowBabylonInspectorUC;
+DispatchShowBabylonInspectorUC.type = 'DispatchShowBabylonInspectorUC';
+function makeDispatchShowBabylonInspectorUC(appObject) {
+    return new DispatchShowBabylonInspectorUCImp(appObject);
+}
+exports.makeDispatchShowBabylonInspectorUC = makeDispatchShowBabylonInspectorUC;
+class DispatchShowBabylonInspectorUCImp extends DispatchShowBabylonInspectorUC {
+    constructor(appObject) {
+        super(appObject, DispatchShowBabylonInspectorUC.type);
+        this.requestVersion = 1;
+        this.dispatcher = appObject.getComponent(Entities_1.HostDispatchEntity.type);
+        if (!this.dispatcher) {
+            this.error('UC has been added to an App Object that does not have a HostDispatchEntity. Add a dispatcher first');
+            this.dispose();
+        }
+    }
+    doDispatch(show) {
+        if (!this.dispatcher)
+            return;
+        const payload = {
+            showBabylonInspector: show,
+        };
+        this.dispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+    }
+}

package/lib/Components/Dispatcher/UCs/DispatchStartAppUC.d.ts

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class DispatchStartAppUC extends HostAppObjectUC {
+    static readonly type = "DispatchStartAppUC";
+    readonly requestType = "START_APP";
+    abstract doDispatch(container: HTMLElement): void;
+    static get(appObject: HostAppObject): DispatchStartAppUC | undefined;
+    static getByID(id: string, appObjects: HostAppObjectRepo): DispatchStartAppUC | undefined;
+}
+export declare function makeDispatchStartAppUC(appObject: HostAppObject): DispatchStartAppUC;

package/lib/Components/Dispatcher/UCs/DispatchStartAppUC.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDispatchStartAppUC = exports.DispatchStartAppUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class DispatchStartAppUC extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "START_APP";
+    }
+    static get(appObject) {
+        const asset = appObject.getComponent(DispatchStartAppUC.type);
+        if (!asset) {
+            appObject.appObjectRepo.submitWarning("DispatchStartAppUC.get", "Unable to find DispatchStartAppUC on app object " + appObject.id);
+        }
+        return asset;
+    }
+    static getByID(id, appObjects) {
+        const appObject = appObjects.get(id);
+        if (!appObject) {
+            appObjects.submitWarning("DispatchStartAppUC.getByID", "Unable to find App Object by id " + id);
+            return undefined;
+        }
+        return DispatchStartAppUC.get(appObject);
+    }
+}
+exports.DispatchStartAppUC = DispatchStartAppUC;
+DispatchStartAppUC.type = "DispatchStartAppUC";
+function makeDispatchStartAppUC(appObject) {
+    return new DispatchStartAppUCImp(appObject);
+}
+exports.makeDispatchStartAppUC = makeDispatchStartAppUC;
+class DispatchStartAppUCImp extends DispatchStartAppUC {
+    constructor(appObject) {
+        super(appObject, DispatchStartAppUC.type);
+        this.requestVersion = 2;
+        this.dispatcher = appObject.getComponent(Entities_1.HostDispatchEntity.type);
+        if (!this.dispatcher) {
+            this.error("UC has been added to an App Object that does not have a HostDispatchEntity. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch(container) {
+        if (!this.dispatcher)
+            return;
+        const payload = {
+            container
+        };
+        this.dispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+    }
+}

package/lib/Components/Dispatcher/UCs/DispatchStartBrowseChannelsUC.d.ts

@@ -0,0 +1,15 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export interface BrowseChannelDTO {
+    channelID: string;
+    container: HTMLDivElement;
+    baseApiURL: string;
+    callback: (modelID: string, dataID: string) => void;
+}
+export declare abstract class DispatchStartBrowseChannelsUC extends HostAppObjectUC {
+    static readonly type = "DispatchStartBrowseChannelsUC";
+    readonly requestType = "START_BROWSE_CHANNEL_MODELS";
+    abstract doDispatch(dto: BrowseChannelDTO): void;
+    static get(appObject: HostAppObject): DispatchStartBrowseChannelsUC | undefined;
+    static getByID(id: string, appObjects: HostAppObjectRepo): DispatchStartBrowseChannelsUC | undefined;
+}
+export declare function makeDispatchStartBrowseChannelsUC(appObject: HostAppObject): DispatchStartBrowseChannelsUC;