@vived/host 3.8.0 → 3.9.1

package/lib/Components/Apps/UCs/Mounters/MounterUC.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMounterUC = exports.MounterUC = void 0;
+const HostAppObject_1 = require("../../../../HostAppObject");
+const Version_1 = require("../../../../ValueObjects/Version");
+const HostDispatchEntity_1 = require("../../../Dispatcher/Entities/HostDispatchEntity");
+const HostHandler_1 = require("../../../Handler/Entities/HostHandler");
+const GetAppFromAPIUC_1 = require("../../../VivedAPI/UCs/GetAppFromAPIUC");
+const AppEntity_1 = require("../../Entities/AppEntity");
+const formAppIDWithVersion_1 = require("../formAppIDWithVersion");
+class MounterUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObject) {
+        return appObject.getComponent(MounterUC.type);
+    }
+    static getById(id, appObjects) {
+        const ao = appObjects.get(id);
+        return ao === null || ao === void 0 ? void 0 : ao.getComponent(MounterUC.type);
+    }
+}
+exports.MounterUC = MounterUC;
+MounterUC.type = "MounterUC";
+function makeMounterUC(appObject) {
+    return new MounterUCImp(appObject);
+}
+exports.makeMounterUC = makeMounterUC;
+class MounterUCImp extends MounterUC {
+    constructor(appObject) {
+        super(appObject, MounterUC.type);
+        this.scriptElements = [];
+        this.unmount = () => {
+            if (!this.app)
+                return;
+            if (!this.app.mountedVersion)
+                return;
+            const versionID = formAppIDWithVersion_1.formAppIDWithVersion(this.app, this.app.mountedVersion);
+            window[versionID] = undefined;
+            delete window[versionID];
+            this.scriptElements.forEach((element) => {
+                element.remove();
+            });
+            this.scriptElements = [];
+            this.app.styles = [];
+            this.app.appAssetFolderURL = undefined;
+            this.app.mountedVersion = undefined;
+            this.app.state = AppEntity_1.AppState.INIT;
+        };
+        this.mount = (majorVersion, minorVersion) => {
+            const fetchApp = this.getAppFromAPI;
+            if (!fetchApp) {
+                this.error("No Fetch App UC");
+                return Promise.reject();
+            }
+            const app = this.app;
+            if (!app) {
+                this.error("No App");
+                return Promise.reject();
+            }
+            const hostHandler = this.hostHandler;
+            if (!hostHandler) {
+                this.error("No Host Handler");
+                return Promise.reject();
+            }
+            const hostDispatcher = this.hostDispatcher;
+            if (!hostDispatcher) {
+                this.error("No Host Dispatcher");
+                return Promise.reject();
+            }
+            const version = this.getAppVersion(majorVersion, minorVersion);
+            if (!version) {
+                return Promise.reject(new Error(`Unable to find version ${majorVersion}.${minorVersion}.X for App ${app.name}`));
+            }
+            this.log(`Initializing App ${app.name} [${app.id}] version ${version.displayString}`);
+            if (app.mountedVersion) {
+                if (Version_1.Version.AreEqual(app.mountedVersion, version)) {
+                    return Promise.resolve();
+                }
+                else {
+                    this.unmount();
+                }
+            }
+            app.state = AppEntity_1.AppState.LOADING;
+            return new Promise((resolve, reject) => {
+                fetchApp
+                    .getApp(this.appObject.id, version.baseVersionString)
+                    .then((appDTO) => {
+                    app.appAssetFolderURL = appDTO.assetFolderURL;
+                    const { scripts, styles } = this.parseEndpoints(appDTO.entrypoints);
+                    app.styles = styles;
+                    return this.loadScripts(scripts, version);
+                })
+                    .then((appInterface) => {
+                    const appHandler = appInterface.mount(hostHandler.handler);
+                    hostDispatcher.registerAppHandler(appHandler);
+                    return this.waitForAppIsReady(app, version);
+                })
+                    .then(() => {
+                    app.mountedVersion = version;
+                    resolve();
+                })
+                    .catch((e) => {
+                    app.state = AppEntity_1.AppState.ERROR;
+                    reject(e);
+                });
+            });
+        };
+        this.loadScripts = (scripts, version) => {
+            const app = this.app;
+            if (!app) {
+                this.error("No app entity");
+                return Promise.reject();
+            }
+            let appInterface = this.getAppInterface(version);
+            const versionID = formAppIDWithVersion_1.formAppIDWithVersion(app, version);
+            if (appInterface) {
+                return Promise.resolve(appInterface);
+            }
+            return new Promise((resolve, reject) => {
+                const loaders = scripts.map((entryPoint) => {
+                    return this.loadScriptIntoDocument(entryPoint, versionID);
+                });
+                Promise.all(loaders)
+                    .then(() => {
+                    appInterface = this.getAppInterface(version);
+                    if (!appInterface) {
+                        reject("App is undefined for ID: " +
+                            app.id +
+                            ". Make sure ID is correct in the 3 files in the app project.");
+                    }
+                    else {
+                        resolve(appInterface);
+                    }
+                })
+                    .catch((e) => {
+                    reject(e);
+                });
+            });
+        };
+        this.loadScriptIntoDocument = (scriptURL, appIDWithVersion) => {
+            return new Promise((resolve, reject) => {
+                const aScript = document.createElement("script");
+                aScript.onload = function onLoad() {
+                    resolve();
+                };
+                aScript.onerror = function onError(e) {
+                    reject(new Error(`Failed to add script to document`));
+                };
+                aScript.type = "text/javascript";
+                aScript.src = scriptURL;
+                aScript.className = appIDWithVersion;
+                this.scriptElements.push(aScript);
+                document.head.appendChild(aScript);
+            });
+        };
+        this.getAppInterface = (version) => {
+            if (!this.app)
+                return;
+            const versionID = formAppIDWithVersion_1.formAppIDWithVersion(this.app, version);
+            let appInterface = window[versionID];
+            if (!appInterface) {
+                appInterface = window[this.app.id]; // Old way of identifying apps
+            }
+            return appInterface;
+        };
+    }
+    get getAppFromAPI() {
+        return this.getCachedSingleton(GetAppFromAPIUC_1.GetAppFromAPIUC.type);
+    }
+    get app() {
+        return this.getCachedLocalComponent(AppEntity_1.AppEntity.type);
+    }
+    get hostHandler() {
+        return this.getCachedLocalComponent(HostHandler_1.HostHandlerEntity.type);
+    }
+    get hostDispatcher() {
+        return this.getCachedLocalComponent(HostDispatchEntity_1.HostDispatchEntity.type);
+    }
+    getAppVersion(major, minor) {
+        if (!this.app) {
+            return;
+        }
+        let appVersion = Version_1.Version.GetLatestWithMajorMinor(this.app.versions, major, minor);
+        if (!appVersion) {
+            appVersion = Version_1.Version.GetLatestWithMajor(this.app.versions, major);
+        }
+        if (!appVersion) {
+            this.error(`Unable to find version ${major}.${minor}.X for App ${this.app.name}`);
+        }
+        return appVersion;
+    }
+    mountLatestVersion() {
+        if (!this.app) {
+            this.error("Missing Components");
+            return Promise.reject();
+        }
+        const version = this.app.latestVersion;
+        if (!version) {
+            this.error("No Version");
+            return Promise.reject();
+        }
+        return this.mount(version.major, version.minor);
+    }
+    parseEndpoints(endpoints) {
+        const scripts = [];
+        const styles = [];
+        endpoints.forEach((endpoint) => {
+            if (endpoint.includes(".js")) {
+                scripts.push(endpoint);
+            }
+            else if (endpoint.includes(".css")) {
+                styles.push(endpoint);
+            }
+            else {
+                this.warn("Unknown endpoint: " + endpoint);
+            }
+        });
+        return {
+            scripts,
+            styles
+        };
+    }
+    waitForAppIsReady(app, appVersion) {
+        // Edge cases here
+        if (app.id === "app4e48fbaa815a4857821bf7569b003751" &&
+            appVersion.major === 1 &&
+            appVersion.minor === 0) {
+            // Mark board app has a problem with version 1.0
+            app.state = AppEntity_1.AppState.READY;
+            return Promise.resolve();
+        }
+        if (app.id === "appe860b51f49414e20ae7995dff4d9b152" &&
+            appVersion.major === 1 &&
+            appVersion.minor <= 2) {
+            // Older versions of the text app do not report when ready
+            app.state = AppEntity_1.AppState.READY;
+            return Promise.resolve();
+        }
+        if (app.id === "app41df8a36f628451d9f633f8a9bdf3edb" &&
+            appVersion.major === 1 &&
+            appVersion.minor <= 1) {
+            // Older versions of the YouTube app do not report when ready
+            app.state = AppEntity_1.AppState.READY;
+            return Promise.resolve();
+        }
+        if (app.id === "app448f8f293fbb493a9e233f113ce8b56a") {
+            // Asset Plugin
+            app.state = AppEntity_1.AppState.READY;
+            return Promise.resolve();
+        }
+        // Allows testing to not get hung up waiting for this
+        if (app.id === "APP_FOR_JEST_TEST") {
+            // Older versions of the YouTube app do not report when ready
+            app.state = AppEntity_1.AppState.READY;
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            const appObserver = () => {
+                if (app.state === AppEntity_1.AppState.READY) {
+                    app.removeChangeObserver(appObserver);
+                    resolve();
+                }
+            };
+            app.addChangeObserver(appObserver);
+        });
+    }
+}

package/lib/Components/Apps/UCs/Mounters/SandboxMounterUC.d.ts

@@ -0,0 +1,3 @@
+import { HostAppObject } from "../../../../HostAppObject/HostAppObject";
+import { MounterUC } from "./MounterUC";
+export declare function makeSandboxMounter(appObject: HostAppObject): MounterUC;

package/lib/Components/Apps/UCs/Mounters/SandboxMounterUC.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSandboxMounter = void 0;
+const Version_1 = require("../../../../ValueObjects/Version");
+const AppSandboxEntity_1 = require("../../../AppSandbox/Entities/AppSandboxEntity");
+const HostDispatchEntity_1 = require("../../../Dispatcher/Entities/HostDispatchEntity");
+const HostHandler_1 = require("../../../Handler/Entities/HostHandler");
+const AppEntity_1 = require("../../Entities/AppEntity");
+const MounterUC_1 = require("./MounterUC");
+function makeSandboxMounter(appObject) {
+    return new SandboxMounterUC(appObject);
+}
+exports.makeSandboxMounter = makeSandboxMounter;
+class SandboxMounterUC extends MounterUC_1.MounterUC {
+    constructor(appObject) {
+        super(appObject, MounterUC_1.MounterUC.type);
+        this.mountLatestVersion = () => {
+            if (!this.appEntity) {
+                this.error("Missing Components");
+                return Promise.reject();
+            }
+            const version = this.appEntity.latestVersion;
+            if (!version) {
+                this.error("No Version");
+                return Promise.reject();
+            }
+            return this.mount(version.major, version.minor);
+        };
+        this.mount = (majorVersion, minorVersion) => {
+            if (!this.appEntity ||
+                !this.hostDispatcher ||
+                !this.hostHandler ||
+                !this.sandbox) {
+                this.error("Missing Components");
+                return Promise.reject();
+            }
+            const version = this.getAppVersion(majorVersion, minorVersion);
+            if (!version) {
+                this.error("No Version");
+                return Promise.reject();
+            }
+            const appInterface = this.getAppInterface(version);
+            if (!appInterface) {
+                this.error("No App Interface");
+                return Promise.reject();
+            }
+            const appHandler = appInterface.mount(this.hostHandler.handler);
+            this.hostDispatcher.registerAppHandler(appHandler);
+            const app = this.appEntity;
+            const sandbox = this.sandbox;
+            return new Promise((resolve) => {
+                const waitForReady = () => {
+                    if (app.state === AppEntity_1.AppState.READY) {
+                        sandbox.state = AppSandboxEntity_1.SandboxState.MOUNTED;
+                        app.removeChangeObserver(waitForReady);
+                        resolve();
+                    }
+                };
+                app.addChangeObserver(waitForReady);
+            });
+        };
+        this.unmount = () => {
+            if (!this.sandbox || !this.hostDispatcher) {
+                this.error("Missing Components");
+                return;
+            }
+            this.hostDispatcher.clearAppHandler();
+            this.sandbox.state = AppSandboxEntity_1.SandboxState.UNMOUNTED;
+        };
+    }
+    get appEntity() {
+        return this.getCachedLocalComponent(AppEntity_1.AppEntity.type);
+    }
+    get hostDispatcher() {
+        return this.getCachedLocalComponent(HostDispatchEntity_1.HostDispatchEntity.type);
+    }
+    get hostHandler() {
+        return this.getCachedLocalComponent(HostHandler_1.HostHandlerEntity.type);
+    }
+    get sandbox() {
+        return this.getCachedSingleton(AppSandboxEntity_1.AppSandboxEntity.type);
+    }
+    getAppVersion(major, minor) {
+        if (!this.appEntity) {
+            return;
+        }
+        let appVersion = Version_1.Version.GetLatestWithMajorMinor(this.appEntity.versions, major, minor);
+        if (!appVersion) {
+            appVersion = Version_1.Version.GetLatestWithMajor(this.appEntity.versions, major);
+        }
+        if (!appVersion) {
+            this.error(`Unable to find version ${major}.${minor}.X for App ${this.appEntity.name}`);
+        }
+        return appVersion;
+    }
+    loadScriptIntoDocument(scriptURL, appIDWithVersion) {
+        // Unused during dev
+        return Promise.resolve();
+    }
+    getAppInterface(version) {
+        const modifiedVersion = version.baseVersionString.split(".").join("_");
+        const idWithVersion = `${this.appObject.id}-${modifiedVersion}`;
+        const appInterface = window[idWithVersion];
+        if (!appInterface) {
+            this.appObjects.submitFatal("LocalMounterUC", "Unable to find App Interface");
+            return;
+        }
+        return appInterface;
+    }
+}

package/lib/Components/Apps/UCs/Mounters/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MounterUC";
+export * from "./SandboxMounterUC";

package/lib/Components/Apps/UCs/Mounters/index.js

@@ -0,0 +1,14 @@
+"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("./MounterUC"), exports);
+__exportStar(require("./SandboxMounterUC"), exports);

package/lib/Components/Apps/UCs/StartAppUC.d.ts

@@ -6,3 +6,4 @@ export declare abstract class StartAppUC extends HostAppObjectUC {
     static getByID(id: string, appObjects: HostAppObjectRepo): StartAppUC | undefined;
     static startByID(container: HTMLElement, id: string, appObjects: HostAppObjectRepo): void;
 }
+export declare function makeStartAppUC(appObject: HostAppObject): StartAppUC;

package/lib/Components/Apps/UCs/StartAppUC.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StartAppUC = void 0;
+exports.makeStartAppUC = exports.StartAppUC = void 0;
 const HostAppObject_1 = require("../../../HostAppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entities_1 = require("../../StateMachine/Entities");
 class StartAppUC extends HostAppObject_1.HostAppObjectUC {
     static get(appObject) {
         const asset = appObject.getComponent(StartAppUC.type);
@@ -25,3 +27,54 @@ class StartAppUC extends HostAppObject_1.HostAppObjectUC {
 }
 exports.StartAppUC = StartAppUC;
 StartAppUC.type = "StartAppUC";
+function makeStartAppUC(appObject) {
+    return new StartAppUCImp(appObject);
+}
+exports.makeStartAppUC = makeStartAppUC;
+class StartAppUCImp extends StartAppUC {
+    constructor(appObject) {
+        super(appObject, StartAppUC.type);
+        this.start = (container) => {
+            var _a, _b, _c;
+            if (!this.stateMachine)
+                return;
+            if (!this.dispatchStart)
+                return;
+            if (!this.editStateEntity)
+                return;
+            this.dispatchStart.doDispatch(container);
+            let stateString = "";
+            if (this.stateMachine.activeState && this.stateMachine.activeState) {
+                const state = this.stateMachine.getStateByID(this.stateMachine.activeState);
+                if (state) {
+                    stateString = JSON.stringify(state.stateData);
+                }
+            }
+            (_a = this.dispatchSetState) === null || _a === void 0 ? void 0 : _a.doDispatch(stateString);
+            let isAuthoring = this.editStateEntity.isEditing;
+            if (this.stateMachine.activeState === undefined) {
+                isAuthoring = true;
+            }
+            (_b = this.dispatchSetIsAuthoring) === null || _b === void 0 ? void 0 : _b.doDispatch(isAuthoring);
+            (_c = this.dispatchThemeColors) === null || _c === void 0 ? void 0 : _c.doDispatch();
+        };
+    }
+    get stateMachine() {
+        return this.getCachedSingleton(Entities_1.HostStateMachine.type);
+    }
+    get editStateEntity() {
+        return this.getCachedSingleton(Entities_1.HostEditingStateEntity.type);
+    }
+    get dispatchStart() {
+        return this.getCachedLocalComponent(Dispatcher_1.DispatchStartAppUC.type);
+    }
+    get dispatchSetState() {
+        return this.getCachedLocalComponent(Dispatcher_1.DispatchSetStateUC.type);
+    }
+    get dispatchSetIsAuthoring() {
+        return this.getCachedLocalComponent(Dispatcher_1.DispatchIsAuthoringUC.type);
+    }
+    get dispatchThemeColors() {
+        return this.getCachedLocalComponent(Dispatcher_1.DispatchThemeUC.type);
+    }
+}

package/lib/Components/Apps/UCs/StopAppUC.d.ts

@@ -6,3 +6,4 @@ export declare abstract class StopAppUC extends HostAppObjectUC {
     static getByID(id: string, appObjects: HostAppObjectRepo): StopAppUC | undefined;
     static stopByID(id: string, appObjects: HostAppObjectRepo): void;
 }
+export declare function makeStopAppUC(appObject: HostAppObject): StopAppUC;

package/lib/Components/Apps/UCs/StopAppUC.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StopAppUC = void 0;
+exports.makeStopAppUC = exports.StopAppUC = void 0;
 const HostAppObject_1 = require("../../../HostAppObject");
+const Dispatcher_1 = require("../../Dispatcher");
 class StopAppUC extends HostAppObject_1.HostAppObjectUC {
     static get(appObject) {
         const asset = appObject.getComponent(StopAppUC.type);
@@ -25,3 +26,19 @@ class StopAppUC extends HostAppObject_1.HostAppObjectUC {
 }
 exports.StopAppUC = StopAppUC;
 StopAppUC.type = "StopAppUC";
+function makeStopAppUC(appObject) {
+    return new StartAppUCImp(appObject);
+}
+exports.makeStopAppUC = makeStopAppUC;
+class StartAppUCImp extends StopAppUC {
+    get dispatchStop() {
+        return this.getCachedLocalComponent(Dispatcher_1.DispatchStopAppUC.type);
+    }
+    stop() {
+        var _a;
+        (_a = this.dispatchStop) === null || _a === void 0 ? void 0 : _a.doDispatch();
+    }
+    constructor(appObject) {
+        super(appObject, StopAppUC.type);
+    }
+}

package/lib/Components/Apps/UCs/formAppIDWithVersion.d.ts

@@ -0,0 +1,3 @@
+import { Version } from "../../../ValueObjects";
+import { AppEntity } from "../Entities";
+export declare function formAppIDWithVersion(app: AppEntity, version: Version): string;

package/lib/Components/Apps/UCs/formAppIDWithVersion.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formAppIDWithVersion = void 0;
+function formAppIDWithVersion(app, version) {
+    const versionString = version.baseVersionString.split(".").join("_");
+    return `${app.id}-${versionString}`;
+}
+exports.formAppIDWithVersion = formAppIDWithVersion;

package/lib/Components/Apps/UCs/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./appIDWithVersion";
-export * from "./MounterUC";
+export * from "./formAppIDWithVersion";
+export * from "./Mounters";
 export * from "./UpdateAppUC";
 export * from "./StartAppUC";
 export * from "./StopAppUC";

package/lib/Components/Apps/UCs/index.js

@@ -10,8 +10,8 @@ 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("./appIDWithVersion"), exports);
-__exportStar(require("./MounterUC"), exports);
+__exportStar(require("./formAppIDWithVersion"), exports);
+__exportStar(require("./Mounters"), exports);
 __exportStar(require("./UpdateAppUC"), exports);
 __exportStar(require("./StartAppUC"), exports);
 __exportStar(require("./StopAppUC"), exports);

package/lib/Components/AssetPlugin/Adapters/assetPluginPMAdapter.js

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assetPluginPMAdapter = void 0;
 const AssetPluginPM_1 = require("../PM/AssetPluginPM");
 exports.assetPluginPMAdapter = {
-    defaultVM: AssetPluginPM_1.defaultAssetPluginVM,
+    defaultVM: {
+        show: false,
+        loading: false,
+        styleSheets: []
+    },
     subscribe: (appObjects, setVM) => {
         const pm = AssetPluginPM_1.AssetPluginPM.get(appObjects);
         if (!pm) {

package/lib/Components/AssetPlugin/Factories/index.d.ts

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

package/lib/Components/AssetPlugin/Factories/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("./setupAssetsPluginForSandbox"), exports);

package/lib/Components/AssetPlugin/Factories/setupAssetsPluginForSandbox.d.ts

@@ -0,0 +1,3 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+import { AssetPluginEntity } from "../Entities";
+export declare function setupAssetsPluginForSandbox(id: string, appObjects: HostAppObjectRepo): AssetPluginEntity;

package/lib/Components/AssetPlugin/Factories/setupAssetsPluginForSandbox.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupAssetsPluginForSandbox = void 0;
+const Apps_1 = require("../../Apps");
+const Dispatcher_1 = require("../../Dispatcher");
+const Handler_1 = require("../../Handler");
+const Entities_1 = require("../Entities");
+const PM_1 = require("../PM");
+const UCs_1 = require("../UCs");
+function setupAssetsPluginForSandbox(id, appObjects) {
+    const ao = appObjects.getOrCreate(id);
+    // Entities
+    const entity = Entities_1.makeAssetPluginEntity(ao);
+    Handler_1.makeHostHandlerEntity(ao);
+    Dispatcher_1.makeHostDispatchEntity(ao);
+    // UCs
+    Apps_1.makeMounterUC(ao);
+    UCs_1.makeSandboxAssetPluginContainerUC(ao);
+    setupDispatchers(ao);
+    setupHandlers(ao);
+    // PMs
+    PM_1.makeAssetPluginPM(ao);
+    return entity;
+}
+exports.setupAssetsPluginForSandbox = setupAssetsPluginForSandbox;
+function setupDispatchers(ao) {
+    Dispatcher_1.makeDispatchStartBrowseChannelsUC(ao);
+    Dispatcher_1.makeDispatchStopAppUC(ao);
+    Dispatcher_1.makeDispatchDisposeAppUC(ao);
+}
+function setupHandlers(ao) {
+    Handler_1.makeGetAssetFolderURLHandler(ao);
+    Handler_1.makeRegisterExternalStyleSheetsHandler(ao);
+    Handler_1.makeCloseAssetSystemPluginUC(ao);
+}

package/lib/Components/AssetPlugin/UCs/SandboxAssetPluginContainerUC.d.ts

@@ -0,0 +1,15 @@
+import { HostAppObject } from "../../../HostAppObject";
+import { AssetPluginContainerUC } from "./AssetPluginContainerUC";
+export declare function makeSandboxAssetPluginContainerUC(appObject: HostAppObject): SandboxAssetPluginContainerUC;
+declare class SandboxAssetPluginContainerUC extends AssetPluginContainerUC {
+    private get mounterUC();
+    private get assetPlugin();
+    private get dispatchStart();
+    private get dispatchStop();
+    private get sandbox();
+    private get vivedAPI();
+    clearContainer: () => void;
+    setContainer: (container: HTMLDivElement) => Promise<void>;
+    constructor(appObject: HostAppObject);
+}
+export {};