@vived/app 3.9.2 → 4.0.0

package/lib/Components/ChannelModel/Entities/ChannelModelRepo.d.ts

@@ -0,0 +1,12 @@
+import { AppObject, AppObjectEntityRepo, AppObjectRepo } from "../../../AppObject";
+import { ChannelModel } from "./ChannelModel";
+export declare class ChannelModelRepo extends AppObjectEntityRepo<ChannelModel> {
+    static readonly type = "CHANNEL_MODEL_REPO";
+    static get: (appObjects: AppObjectRepo) => ChannelModelRepo | undefined;
+    static addToAO(appObj: AppObject): ChannelModelRepo;
+    private memoizedIsLoading;
+    get isLoadingChannelModel(): boolean;
+    set isLoadingChannelModel(val: boolean);
+    makeIfMissing(appObject: AppObject): ChannelModel;
+    constructor(appObject: AppObject);
+}

package/lib/Components/ChannelModel/Entities/ChannelModelRepo.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelModelRepo = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+const ChannelModel_1 = require("./ChannelModel");
+class ChannelModelRepo extends AppObject_1.AppObjectEntityRepo {
+    constructor(appObject) {
+        super(appObject, ChannelModelRepo.type);
+        this.memoizedIsLoading = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+    }
+    static addToAO(appObj) {
+        return new ChannelModelRepo(appObj);
+    }
+    get isLoadingChannelModel() {
+        return this.memoizedIsLoading.val;
+    }
+    set isLoadingChannelModel(val) {
+        this.memoizedIsLoading.val = val;
+    }
+    makeIfMissing(appObject) {
+        const existing = this.getForAppObject(appObject.id);
+        if (existing) {
+            return existing;
+        }
+        else {
+            const newEntity = new ChannelModel_1.ChannelModel(appObject);
+            this.add(newEntity);
+            return newEntity;
+        }
+    }
+}
+exports.ChannelModelRepo = ChannelModelRepo;
+ChannelModelRepo.type = "CHANNEL_MODEL_REPO";
+ChannelModelRepo.get = (appObjects) => AppObject_1.getSingletonComponent(ChannelModelRepo.type, appObjects);

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

@@ -0,0 +1,2 @@
+export * from "./ChannelModel";
+export * from "./ChannelModelRepo";

package/lib/Components/ChannelModel/Entities/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("./ChannelModel"), exports);
+__exportStar(require("./ChannelModelRepo"), exports);

package/lib/Components/ChannelModel/UC/ProcessChannelModelUC.d.ts

@@ -0,0 +1,6 @@
+import { AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class ProcessChannelModelUC extends AppObjectUC {
+    static readonly type: string;
+    abstract processChannelModel: (modelAssetID: string) => Promise<void>;
+    static get: (appObjects: AppObjectRepo) => ProcessChannelModelUC | undefined;
+}

package/lib/Components/ChannelModel/UC/ProcessChannelModelUC.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessChannelModelUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+class ProcessChannelModelUC extends AppObject_1.AppObjectUC {
+}
+exports.ProcessChannelModelUC = ProcessChannelModelUC;
+ProcessChannelModelUC.type = "ProcessChannelModelUC";
+ProcessChannelModelUC.get = (appObjects) => AppObject_1.getSingletonComponent(ProcessChannelModelUC.type, appObjects);

package/lib/Components/ChannelModel/UC/SelectChannelModelUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class SelectChannelModelUC extends AppObjectUC {
+    static readonly type: string;
+    abstract selectChannelModel: () => Promise<string>;
+    static get: (appObjects: AppObjectRepo) => SelectChannelModelUC | undefined;
+}
+export declare function makeSelectChannelModelUC(appObject: AppObject): SelectChannelModelUC;

package/lib/Components/ChannelModel/UC/SelectChannelModelUC.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSelectChannelModelUC = exports.SelectChannelModelUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRoot_1 = require("../../SceneRoot");
+const SetupChannelModelUC_1 = require("./SetupChannelModelUC");
+class SelectChannelModelUC extends AppObject_1.AppObjectUC {
+}
+exports.SelectChannelModelUC = SelectChannelModelUC;
+SelectChannelModelUC.type = "SelectChannelModelUC";
+SelectChannelModelUC.get = (appObjects) => AppObject_1.getSingletonComponent(SelectChannelModelUC.type, appObjects);
+function makeSelectChannelModelUC(appObject) {
+    return new SelectChannelModelUCImp(appObject);
+}
+exports.makeSelectChannelModelUC = makeSelectChannelModelUC;
+class SelectChannelModelUCImp extends SelectChannelModelUC {
+    constructor(appObject) {
+        super(appObject, SelectChannelModelUC.type);
+        this.selectChannelModel = () => {
+            return new Promise((resolve, reject) => {
+                const appObjects = this.appObject.appObjectRepo;
+                const setupChannelModelUC = SetupChannelModelUC_1.SetupChannelModelUC.get(appObjects);
+                if (!setupChannelModelUC) {
+                    this.warn("Unable to get setupChannelModelUC from the model repo App Object");
+                    reject(new Error("Unable to get setupChannelModelUC from the model repo App Object"));
+                    return;
+                }
+                const showSelectModel = Dispatcher_1.ShowSelectModelUC.get(appObjects);
+                if (!showSelectModel) {
+                    this.warn("Unable to find show select model UC");
+                    reject(new Error("Unable to find show select model UC"));
+                    return;
+                }
+                let modelID = "";
+                showSelectModel
+                    .doDispatch()
+                    .then((resp) => {
+                    modelID = resp.modelId;
+                    return setupChannelModelUC.setupChannelModel(modelID);
+                })
+                    .then((channelModel) => {
+                    const sceneRoot = SceneRoot_1.SceneRootEntity.get(appObjects);
+                    if (!sceneRoot)
+                        return;
+                    sceneRoot.position = channelModel.defaultPosition;
+                    sceneRoot.rotation = channelModel.defaultRotation;
+                    sceneRoot.scale = channelModel.defaultScale;
+                    resolve(modelID);
+                })
+                    .catch((e) => {
+                    reject(e);
+                });
+            });
+        };
+    }
+}

package/lib/Components/ChannelModel/UC/SetupChannelModelUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { ChannelModel } from "../Entities";
+export declare const SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+export declare abstract class SetupChannelModelUC extends AppObjectUC {
+    static readonly type: string;
+    static readonly SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+    abstract setupChannelModel(modelID: string): Promise<ChannelModel>;
+    static get: (appObjects: AppObjectRepo) => SetupChannelModelUC | undefined;
+}
+export declare function makeSetupChannelModelUC(appObject: AppObject): SetupChannelModelUC;

package/lib/Components/ChannelModel/UC/SetupChannelModelUC.js

@@ -0,0 +1,141 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetupChannelModelUC = exports.SetupChannelModelUC = exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Dispatcher_1 = require("../../Dispatcher");
+const Label_1 = require("../../Label");
+const Mesh_1 = require("../../Mesh");
+const Entities_1 = require("../Entities");
+const ProcessChannelModelUC_1 = require("./ProcessChannelModelUC");
+exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+class SetupChannelModelUC extends AppObject_1.AppObjectUC {
+}
+exports.SetupChannelModelUC = SetupChannelModelUC;
+SetupChannelModelUC.type = "SetupChannelModelUC";
+SetupChannelModelUC.SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+SetupChannelModelUC.get = (appObjects) => AppObject_1.getSingletonComponent(SetupChannelModelUC.type, appObjects);
+function makeSetupChannelModelUC(appObject) {
+    return new SetupChannelModelUCImp(appObject);
+}
+exports.makeSetupChannelModelUC = makeSetupChannelModelUC;
+class SetupChannelModelUCImp extends SetupChannelModelUC {
+    constructor(appObject) {
+        super(appObject, SetupChannelModelUC.type);
+        this.setupChannelModel = (modelID) => __awaiter(this, void 0, void 0, function* () {
+            const channelModelRepo = this.appObject.getComponent(Entities_1.ChannelModelRepo.type);
+            if (!channelModelRepo) {
+                this.warn("Unable to get channelModelRepo from the model repo App Object");
+                return Promise.reject(new Error("No Channel Model Repo"));
+            }
+            const processModel = ProcessChannelModelUC_1.ProcessChannelModelUC.get(this.appObjects);
+            if (!processModel) {
+                return Promise.reject(new Error("No Process ModelUC"));
+            }
+            const appObj = this.appObjects.getOrCreate(modelID);
+            const channelModel = channelModelRepo.makeIfMissing(appObj);
+            if (channelModel.state === Entities_1.ChannelModelState.LOADING) {
+                return Promise.resolve(channelModel);
+            }
+            if (channelModel.state === Entities_1.ChannelModelState.READY) {
+                return Promise.resolve(channelModel);
+            }
+            channelModel.modelError = undefined;
+            channelModel.state = Entities_1.ChannelModelState.LOADING;
+            channelModelRepo.isLoadingChannelModel = true;
+            const spinner = Dispatcher_1.ShowSpinnerUC.get(this.appObjects);
+            let closeSpinner = () => {
+                // done
+            };
+            if (spinner) {
+                closeSpinner = yield spinner.showSpinner("Loading active model and data", "Loading...");
+            }
+            try {
+                const { bounds_max, bounds_min, defaultPosition, defaultRotation, defaultScale, name, objects, } = yield this.modelDataLoader(modelID);
+                channelModel.name = name;
+                channelModel.bounds_max = ValueObjects_1.Vector3.FromDTO(bounds_max);
+                channelModel.bounds_min = ValueObjects_1.Vector3.FromDTO(bounds_min);
+                channelModel.defaultPosition = ValueObjects_1.Vector3.FromDTO(defaultPosition);
+                channelModel.defaultScale = defaultScale;
+                channelModel.defaultRotation = ValueObjects_1.Quaternion.FromDTO(defaultRotation);
+                const meshes = [];
+                objects.forEach((mesh) => {
+                    const { id, label, meshPaths } = mesh;
+                    meshes.push(mesh.id);
+                    this.setupMeshObject(id, label, meshPaths);
+                });
+                channelModel.meshList = meshes;
+                yield processModel.processChannelModel(modelID);
+                channelModel.state = Entities_1.ChannelModelState.READY;
+                channelModelRepo.isLoadingChannelModel = false;
+                Dispatcher_1.dispatchStateChange(this.appObjects);
+                closeSpinner();
+                return Promise.resolve(channelModel);
+            }
+            catch (e) {
+                const error = e;
+                if (channelModelRepo) {
+                    channelModelRepo.isLoadingChannelModel = false;
+                }
+                channelModel.modelError = error;
+                closeSpinner();
+                const alertDTO = {
+                    title: "Load Error",
+                    message: `Failed to Load the Model and Data. Error message: ${error.message}`,
+                    closeButtonLabel: "OK",
+                    closeCallback: () => {
+                        // done
+                    },
+                };
+                const showAlertUC = Dispatcher_1.ShowAlertUC.get(this.appObjects);
+                if (showAlertUC) {
+                    showAlertUC.showAlert(alertDTO);
+                }
+                else {
+                    this.warn(alertDTO.message);
+                }
+                return Promise.reject(error);
+            }
+        });
+    }
+    setupMeshObject(id, label, meshPaths) {
+        const appObj = this.appObjects.getOrCreate(id);
+        const labelEntity = Label_1.Label.addIfMissing(appObj);
+        labelEntity.default = label;
+        const meshEntity = Mesh_1.Mesh.addIfMissing(appObj);
+        meshPaths.forEach((meshPath) => {
+            meshEntity.addSubMesh({
+                meshPath,
+                neutralPosition: ValueObjects_1.Vector3.Zero(),
+                neutralRotation: ValueObjects_1.Quaternion.Identity(),
+                neutralScale: ValueObjects_1.Vector3.One(),
+            });
+        });
+    }
+    modelDataLoader(modelID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const dataAssets = yield Dispatcher_1.getLinkedAssets(modelID, SetupChannelModelUC.SCENE_MODEL_DATA_ASSET_LINK_TYPE, this.appObjects);
+                if (dataAssets.length === 0) {
+                    return Promise.reject(new Error("Model asset does not have data"));
+                }
+                const dataFileBlobURL = yield Dispatcher_1.getAssetBlobURL(dataAssets[0].id, this.appObjects);
+                const fetchDataResp = yield fetch(dataFileBlobURL);
+                const modelJSONData = yield fetchDataResp.json();
+                return Promise.resolve(modelJSONData);
+            }
+            catch (e) {
+                return Promise.reject(e);
+            }
+        });
+    }
+}

package/lib/Components/ChannelModel/UC/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ProcessChannelModelUC";
+export * from "./SelectChannelModelUC";
+export * from "./SetupChannelModelUC";

package/lib/Components/ChannelModel/UC/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ProcessChannelModelUC"), exports);
+__exportStar(require("./SelectChannelModelUC"), exports);
+__exportStar(require("./SetupChannelModelUC"), exports);

package/lib/Components/ChannelModel/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Entities";
+export * from "./UC";

package/lib/Components/ChannelModel/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("./Entities"), exports);
+__exportStar(require("./UC"), exports);

package/lib/Components/Dispatcher/Controllers/dispatchStopZSpace.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject";
+export declare function dispatchStopZSpace(appObjects: AppObjectRepo): void;

package/lib/Components/Dispatcher/Controllers/dispatchStopZSpace.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchStopZSpace = void 0;
+const UC_1 = require("../UC");
+function dispatchStopZSpace(appObjects) {
+    const uc = UC_1.DispatchStopZSpaceUC.get(appObjects);
+    if (uc) {
+        uc.doDispatch();
+    }
+    else {
+        appObjects.submitWarning("dispatchStopZSpace", "Can't find DispatchStopZSpaceUC");
+    }
+}
+exports.dispatchStopZSpace = dispatchStopZSpace;

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

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

package/lib/Components/Dispatcher/Controllers/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("./dispatchStopZSpace"), exports);

package/lib/Components/Dispatcher/Entities/AppDispatcher.d.ts

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+import { Handler, Request } from "../../../Types";
+export declare abstract class AppDispatcher extends AppObjectEntity {
+    static readonly type = "APP_DISPATCHER";
+    abstract dispatch: (request: Request) => void;
+    abstract formRequestAndDispatch: (type: string, version: number, payload?: object | undefined) => void;
+    static get: (appObjects: AppObjectRepo) => AppDispatcher | undefined;
+}
+export declare function makeAppDispatcher(appObject: AppObject, hostHandler: Handler): AppDispatcher;

package/lib/Components/Dispatcher/Entities/AppDispatcher.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppDispatcher = exports.AppDispatcher = void 0;
+const AppObject_1 = require("../../../AppObject");
+class AppDispatcher extends AppObject_1.AppObjectEntity {
+}
+exports.AppDispatcher = AppDispatcher;
+AppDispatcher.type = "APP_DISPATCHER";
+AppDispatcher.get = (appObjects) => AppObject_1.getSingletonComponent(AppDispatcher.type, appObjects);
+function makeAppDispatcher(appObject, hostHandler) {
+    return new AppDispatcherImp(appObject, hostHandler);
+}
+exports.makeAppDispatcher = makeAppDispatcher;
+class AppDispatcherImp extends AppDispatcher {
+    constructor(appObject, hostHandler) {
+        super(appObject, AppDispatcher.type);
+        this.hostHandler = hostHandler;
+        this.dispatch = (request) => {
+            this.hostHandler(request);
+        };
+        this.formRequestAndDispatch = (type, version, payload) => {
+            const request = {
+                type,
+                version,
+                payload,
+            };
+            this.hostHandler(request);
+        };
+    }
+}

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

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

package/lib/Components/Dispatcher/Entities/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("./AppDispatcher"), exports);

package/lib/Components/Dispatcher/UC/AppIsReadyUC.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 AppIsReadyUC extends AppObjectUC {
+    static readonly type = "AppIsReadyUC";
+    readonly requestType = "APP_IS_READY";
+    abstract doDispatch(): void;
+    static get: (appObjects: AppObjectRepo) => AppIsReadyUC | undefined;
+}
+export declare function makeAppIsReadyUC(appObject: AppObject): AppIsReadyUC;
+export declare function appIsReady(appObjects: AppObjectRepo): void;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appIsReady = exports.makeAppIsReadyUC = exports.AppIsReadyUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class AppIsReadyUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "APP_IS_READY";
+    }
+}
+exports.AppIsReadyUC = AppIsReadyUC;
+AppIsReadyUC.type = "AppIsReadyUC";
+AppIsReadyUC.get = (appObjects) => AppObject_1.getSingletonComponent(AppIsReadyUC.type, appObjects);
+function makeAppIsReadyUC(appObject) {
+    return new AppIsReadyUCImp(appObject);
+}
+exports.makeAppIsReadyUC = makeAppIsReadyUC;
+function appIsReady(appObjects) {
+    const dispatchUC = AppIsReadyUC.get(appObjects);
+    if (dispatchUC) {
+        dispatchUC.doDispatch();
+    }
+    else {
+        appObjects.submitWarning("appIsReady", "Can't find AppIsReadyUC");
+    }
+}
+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) {
+            this.warn("AppIsReadyUCImp has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        if (!this.appDispatcher)
+            return;
+        this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion);
+    }
+}

package/lib/Components/Dispatcher/UC/DispatchStartZSpaceUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class DispatchStartZSpaceUC extends AppObjectUC {
+    static readonly type = "DispatchStartZSpaceUC";
+    readonly requestType = "START_ZSPACE";
+    abstract doDispatch(): void;
+    static get: (appObjects: AppObjectRepo) => DispatchStartZSpaceUC | undefined;
+}
+export declare function makeDispatchStartZSpaceUC(appObject: AppObject): DispatchStartZSpaceUC;

package/lib/Components/Dispatcher/UC/DispatchStartZSpaceUC.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDispatchStartZSpaceUC = exports.DispatchStartZSpaceUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class DispatchStartZSpaceUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "START_ZSPACE";
+    }
+}
+exports.DispatchStartZSpaceUC = DispatchStartZSpaceUC;
+DispatchStartZSpaceUC.type = "DispatchStartZSpaceUC";
+DispatchStartZSpaceUC.get = (appObjects) => AppObject_1.getSingletonComponent(DispatchStartZSpaceUC.type, appObjects);
+function makeDispatchStartZSpaceUC(appObject) {
+    return new DispatchStateChangeUCImp(appObject);
+}
+exports.makeDispatchStartZSpaceUC = makeDispatchStartZSpaceUC;
+class DispatchStateChangeUCImp extends DispatchStartZSpaceUC {
+    constructor(appObject) {
+        super(appObject, DispatchStartZSpaceUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            this.warn("DispatchStartZSpaceUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        if (!this.appDispatcher)
+            return;
+        this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion);
+    }
+}

package/lib/Components/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/Components/Dispatcher/UC/DispatchStateChangeUC.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchStateChange = exports.makeDispatchStateChangeUC = exports.DispatchStateChangeUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+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";
+    }
+}
+exports.DispatchStateChangeUC = DispatchStateChangeUC;
+DispatchStateChangeUC.type = "DispatchStateChangeUC";
+DispatchStateChangeUC.get = (appObjects) => AppObject_1.getSingletonComponent(DispatchStateChangeUC.type, appObjects);
+function makeDispatchStateChangeUC(appObject) {
+    return new DispatchStateChangeUCImp(appObject);
+}
+exports.makeDispatchStateChangeUC = makeDispatchStateChangeUC;
+function dispatchStateChange(appObjects) {
+    const dispatchUC = DispatchStateChangeUC.get(appObjects);
+    if (dispatchUC) {
+        dispatchUC.doDispatch();
+    }
+    else {
+        appObjects.submitWarning("dispatchStateChange", "Can't find DispatchStateChangeUC");
+    }
+}
+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) {
+            this.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) {
+            this.warn("Could not find StateMachineEntity");
+            return;
+        }
+        const baseApp = App_1.BaseAppState.get(this.appObject.appObjectRepo);
+        if (!baseApp) {
+            this.warn("Could not find BaseAppState");
+            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);
+    }
+}