@vived/host 3.7.0 → 3.9.0

package/lib/Components/StateMachine/UCs/EditActiveState/EditActiveSandboxStateUC.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEditActiveSandboxStateUC = void 0;
+const AppSandboxEntity_1 = require("../../../AppSandbox/Entities/AppSandboxEntity");
+const UCs_1 = require("../../../Dispatcher/UCs");
+const Entities_1 = require("../../Entities");
+const EditActiveStateUC_1 = require("./EditActiveStateUC");
+function makeEditActiveSandboxStateUC(appObject) {
+    return new EditActiveSandboxStateUCImp(appObject);
+}
+exports.makeEditActiveSandboxStateUC = makeEditActiveSandboxStateUC;
+class EditActiveSandboxStateUCImp extends EditActiveStateUC_1.EditActiveStateUC {
+    constructor(appObject) {
+        super(appObject, EditActiveStateUC_1.EditActiveStateUC.type);
+        this.editActiveState = () => {
+            if (!this.sandbox || !this.stateMachine || !this.editStateEntity)
+                return;
+            const dispatchSetIsAuthoring = UCs_1.DispatchIsAuthoringUC.getByID(this.sandbox.appID, this.appObjects);
+            if (!dispatchSetIsAuthoring) {
+                this.error("Unable to find DispatchIsAuthoringUC");
+                return;
+            }
+            const dispatchSetState = UCs_1.DispatchSetStateUC.getByID(this.sandbox.appID, this.appObjects);
+            if (!dispatchSetState) {
+                this.error("Unable to find DispatchIsAuthoringUC");
+                return;
+            }
+            if (!this.stateMachine.activeState) {
+                this.error("No active slide");
+                return;
+            }
+            const state = this.stateMachine.getStateByID(this.stateMachine.activeState);
+            if (!state) {
+                this.warn("Unable to find state");
+                return;
+            }
+            const stateStr = JSON.stringify(state.stateData);
+            dispatchSetState.doDispatch(stateStr);
+            dispatchSetIsAuthoring.doDispatch(true);
+            this.editStateEntity.startEditing(state);
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get sandbox() {
+        return this.getCachedSingleton(AppSandboxEntity_1.AppSandboxEntity.type);
+    }
+    get stateMachine() {
+        return this.getCachedSingleton(Entities_1.HostStateMachine.type);
+    }
+    get editStateEntity() {
+        return this.getCachedSingleton(Entities_1.HostEditingStateEntity.type);
+    }
+}

package/lib/Components/StateMachine/UCs/EditActiveState/EditActiveStateUC.d.ts

@@ -0,0 +1,6 @@
+import { HostAppObjectRepo, HostAppObjectUC } from "../../../../HostAppObject";
+export declare abstract class EditActiveStateUC extends HostAppObjectUC {
+    static type: string;
+    static get(appObjects: HostAppObjectRepo): EditActiveStateUC | undefined;
+    abstract editActiveState(): void;
+}

package/lib/Components/StateMachine/UCs/EditActiveState/EditActiveStateUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditActiveStateUC = void 0;
+const HostAppObject_1 = require("../../../../HostAppObject");
+class EditActiveStateUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(EditActiveStateUC.type, appObjects);
+    }
+}
+exports.EditActiveStateUC = EditActiveStateUC;
+EditActiveStateUC.type = "EditActiveStateUC";

package/lib/Components/StateMachine/UCs/EditActiveState/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./EditActiveSandboxStateUC";
+export * from "./EditActiveStateUC";

package/lib/Components/StateMachine/UCs/EditActiveState/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("./EditActiveSandboxStateUC"), exports);
+__exportStar(require("./EditActiveStateUC"), exports);

package/lib/Components/StateMachine/UCs/EditState/EditSandboxStateUC.d.ts

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

package/lib/Components/StateMachine/UCs/EditState/EditSandboxStateUC.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEditSandboxStateUC = void 0;
+const Entities_1 = require("../../../AppSandbox/Entities");
+const Entities_2 = require("../../Entities");
+const EditStateUC_1 = require("./EditStateUC");
+function makeEditSandboxStateUC(appObject) {
+    return new EditSandboxStateUC(appObject);
+}
+exports.makeEditSandboxStateUC = makeEditSandboxStateUC;
+class EditSandboxStateUC extends EditStateUC_1.EditStateUC {
+    get sandbox() {
+        return this.getCachedSingleton(Entities_1.AppSandboxEntity.type);
+    }
+    get stateMachine() {
+        return this.getCachedSingleton(Entities_2.HostStateMachine.type);
+    }
+    get editStateEntity() {
+        return this.getCachedSingleton(Entities_2.HostEditingStateEntity.type);
+    }
+    edit(id) {
+        if (!this.sandbox || !this.stateMachine || !this.editStateEntity)
+            return;
+        const state = this.stateMachine.getStateByID(id);
+        if (!state) {
+            this.warn("Unable to find state");
+            return;
+        }
+        this.stateMachine.setActiveStateByID(id);
+        this.editStateEntity.startEditing(state);
+        this.sandbox.state = Entities_1.SandboxState.PLAYING;
+    }
+    constructor(appObject) {
+        super(appObject, EditStateUC_1.EditStateUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}

package/lib/Components/StateMachine/UCs/EditState/EditStateUC.d.ts

@@ -0,0 +1,6 @@
+import { HostAppObjectRepo, HostAppObjectUC } from "../../../../HostAppObject";
+export declare abstract class EditStateUC extends HostAppObjectUC {
+    static type: string;
+    abstract edit(id: string): void;
+    static get(appObjects: HostAppObjectRepo): EditStateUC | undefined;
+}

package/lib/Components/StateMachine/UCs/EditState/EditStateUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditStateUC = void 0;
+const HostAppObject_1 = require("../../../../HostAppObject");
+class EditStateUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(EditStateUC.type, appObjects);
+    }
+}
+exports.EditStateUC = EditStateUC;
+EditStateUC.type = "EditStateUC";

package/lib/Components/StateMachine/UCs/EditState/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./EditSandboxStateUC";
+export * from "./EditStateUC";

package/lib/Components/StateMachine/UCs/EditState/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("./EditSandboxStateUC"), exports);
+__exportStar(require("./EditStateUC"), exports);

package/lib/Components/StateMachine/UCs/EndActivity/EndActivityUC.d.ts

@@ -0,0 +1,6 @@
+import { HostAppObjectRepo, HostAppObjectUC } from "../../../../HostAppObject";
+export declare abstract class EndActivityUC extends HostAppObjectUC {
+    static type: string;
+    abstract end(): void;
+    static get(appObjects: HostAppObjectRepo): EndActivityUC | undefined;
+}

package/lib/Components/StateMachine/UCs/EndActivity/EndActivityUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndActivityUC = void 0;
+const HostAppObject_1 = require("../../../../HostAppObject");
+class EndActivityUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(EndActivityUC.type, appObjects);
+    }
+}
+exports.EndActivityUC = EndActivityUC;
+EndActivityUC.type = "EndActivityUC";

package/lib/Components/StateMachine/UCs/EndActivity/EndSandboxActivityUC.d.ts

@@ -0,0 +1,3 @@
+import { HostAppObject } from "../../../../HostAppObject";
+import { EndActivityUC } from "./EndActivityUC";
+export declare function makeEndSandboxActivityUC(appObj: HostAppObject): EndActivityUC;

package/lib/Components/StateMachine/UCs/EndActivity/EndSandboxActivityUC.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEndSandboxActivityUC = void 0;
+const Entities_1 = require("../../../AppSandbox/Entities");
+const ZSpaceHost_1 = require("../../../ZSpaceHost");
+const Entities_2 = require("../../Entities");
+const EndActivityUC_1 = require("./EndActivityUC");
+function makeEndSandboxActivityUC(appObj) {
+    return new EndSandboxActivityUC(appObj);
+}
+exports.makeEndSandboxActivityUC = makeEndSandboxActivityUC;
+class EndSandboxActivityUC extends EndActivityUC_1.EndActivityUC {
+    get zSpace() {
+        return this.getCachedSingleton(ZSpaceHost_1.ZSpaceHostEntity.type);
+    }
+    get stopZSpaceUC() {
+        return this.getCachedSingleton(ZSpaceHost_1.StopZSpaceUC.type);
+    }
+    get sandbox() {
+        return this.getCachedSingleton(Entities_1.AppSandboxEntity.type);
+    }
+    get stateMachine() {
+        return this.getCachedSingleton(Entities_2.HostStateMachine.type);
+    }
+    end() {
+        var _a, _b, _c;
+        if ((_a = this.zSpace) === null || _a === void 0 ? void 0 : _a.isActive) {
+            (_b = this.stopZSpaceUC) === null || _b === void 0 ? void 0 : _b.stopZSpace();
+        }
+        (_c = this.stateMachine) === null || _c === void 0 ? void 0 : _c.clearActiveState();
+        if (this.sandbox) {
+            this.sandbox.state = Entities_1.SandboxState.MOUNTED;
+        }
+    }
+    constructor(appObject) {
+        super(appObject, EndActivityUC_1.EndActivityUC.type);
+    }
+}

package/lib/Components/StateMachine/UCs/EndActivity/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./EndActivityUC";
+export * from "./EndSandboxActivityUC";

package/lib/Components/StateMachine/UCs/EndActivity/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("./EndActivityUC"), exports);
+__exportStar(require("./EndSandboxActivityUC"), exports);

package/lib/Components/StateMachine/UCs/NewState/NewSandboxStateUC.d.ts

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

package/lib/Components/StateMachine/UCs/NewState/NewSandboxStateUC.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNewSandboxStateUC = void 0;
+const Entities_1 = require("../../../AppSandbox/Entities");
+const Entities_2 = require("../../Entities");
+const NewStateUC_1 = require("./NewStateUC");
+function makeNewSandboxStateUC(appObject) {
+    return new NewSandboxStateUC(appObject);
+}
+exports.makeNewSandboxStateUC = makeNewSandboxStateUC;
+class NewSandboxStateUC extends NewStateUC_1.NewStateUC {
+    constructor(appObject) {
+        super(appObject, NewStateUC_1.NewStateUC.type);
+        this.createState = () => {
+            if (!this.sandbox || !this.stateMachine || !this.editStateEntity)
+                return;
+            this.stateMachine.clearActiveState();
+            const newState = this.editStateEntity.startNewState();
+            if (!newState)
+                return;
+            this.sandbox.state = Entities_1.SandboxState.PLAYING;
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get sandbox() {
+        return this.getCachedSingleton(Entities_1.AppSandboxEntity.type);
+    }
+    get stateMachine() {
+        return this.getCachedSingleton(Entities_2.HostStateMachine.type);
+    }
+    get editStateEntity() {
+        return this.getCachedSingleton(Entities_2.HostEditingStateEntity.type);
+    }
+}

package/lib/Components/StateMachine/UCs/NewState/NewStateUC.d.ts

@@ -0,0 +1,6 @@
+import { HostAppObjectRepo, HostAppObjectUC } from "../../../../HostAppObject";
+export declare abstract class NewStateUC extends HostAppObjectUC {
+    static type: string;
+    abstract createState(): void;
+    static get(appObjects: HostAppObjectRepo): NewStateUC | undefined;
+}

package/lib/Components/StateMachine/UCs/NewState/NewStateUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewStateUC = void 0;
+const HostAppObject_1 = require("../../../../HostAppObject");
+class NewStateUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(NewStateUC.type, appObjects);
+    }
+}
+exports.NewStateUC = NewStateUC;
+NewStateUC.type = "NewStateUC";

package/lib/Components/StateMachine/UCs/NewState/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./NewSandboxStateUC";
+export * from "./NewStateUC";

package/lib/Components/StateMachine/UCs/NewState/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("./NewSandboxStateUC"), exports);
+__exportStar(require("./NewStateUC"), exports);

package/lib/Components/StateMachine/UCs/SaveAuthoring/SaveAuthoringSandboxUC.d.ts

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

package/lib/Components/StateMachine/UCs/SaveAuthoring/SaveAuthoringSandboxUC.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSaveAuthoringSandboxUC = void 0;
+const Entities_1 = require("../../../AppSandbox/Entities");
+const Dispatcher_1 = require("../../../Dispatcher");
+const Entities_2 = require("../../Entities");
+const SaveAuthoringUC_1 = require("./SaveAuthoringUC");
+function makeSaveAuthoringSandboxUC(appObject) {
+    return new SaveAuthoringSandboxUCImp(appObject);
+}
+exports.makeSaveAuthoringSandboxUC = makeSaveAuthoringSandboxUC;
+class SaveAuthoringSandboxUCImp extends SaveAuthoringUC_1.SaveAuthoringUC {
+    constructor(appObject) {
+        super(appObject, SaveAuthoringUC_1.SaveAuthoringUC.type);
+        this.newStateDefaultName = "New State";
+        this.saveAuthoring = () => {
+            if (!this.sandbox || !this.stateMachine || !this.editStateEntity)
+                return;
+            if (this.editStateEntity.stateValidationMessage) {
+                window.alert(this.editStateEntity.stateValidationMessage);
+                return;
+            }
+            if (this.editStateEntity.isNewState && this.editStateEntity.editingState) {
+                this.stateMachine.setActiveStateByID(this.editStateEntity.editingState.id);
+                this.editStateEntity.editingState.name = "New State";
+            }
+            this.editStateEntity.finishEditing();
+            const dispatchSetIsAuthoring = Dispatcher_1.DispatchIsAuthoringUC.getByID(this.sandbox.appID, this.appObjects);
+            if (!dispatchSetIsAuthoring) {
+                this.error("Unable to find DispatchIsAuthoringUC");
+                return;
+            }
+            dispatchSetIsAuthoring.doDispatch(false);
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get sandbox() {
+        return this.getCachedSingleton(Entities_1.AppSandboxEntity.type);
+    }
+    get stateMachine() {
+        return this.getCachedSingleton(Entities_2.HostStateMachine.type);
+    }
+    get editStateEntity() {
+        return this.getCachedSingleton(Entities_2.HostEditingStateEntity.type);
+    }
+}

package/lib/Components/StateMachine/UCs/SaveAuthoring/SaveAuthoringUC.d.ts

@@ -0,0 +1,6 @@
+import { HostAppObjectRepo, HostAppObjectUC } from "../../../../HostAppObject";
+export declare abstract class SaveAuthoringUC extends HostAppObjectUC {
+    static type: string;
+    static get(appObjects: HostAppObjectRepo): SaveAuthoringUC | undefined;
+    abstract saveAuthoring(): void;
+}

package/lib/Components/StateMachine/UCs/SaveAuthoring/SaveAuthoringUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveAuthoringUC = void 0;
+const HostAppObject_1 = require("../../../../HostAppObject");
+class SaveAuthoringUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(SaveAuthoringUC.type, appObjects);
+    }
+}
+exports.SaveAuthoringUC = SaveAuthoringUC;
+SaveAuthoringUC.type = "SaveAuthoringUC";

package/lib/Components/StateMachine/UCs/SaveAuthoring/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./SaveAuthoringSandboxUC";
+export * from "./SaveAuthoringUC";

package/lib/Components/StateMachine/UCs/SaveAuthoring/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("./SaveAuthoringSandboxUC"), exports);
+__exportStar(require("./SaveAuthoringUC"), exports);

package/lib/Components/StateMachine/UCs/SavePersistentStates.d.ts

@@ -0,0 +1,7 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class SavePersistentStatesUC extends HostAppObjectUC {
+    static type: string;
+    abstract saveLocally(): void;
+    static get(appObjects: HostAppObjectRepo): SavePersistentStatesUC | undefined;
+}
+export declare function makeSavePersistentStatesUC(appObject: HostAppObject): SavePersistentStatesUC;

package/lib/Components/StateMachine/UCs/SavePersistentStates.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSavePersistentStatesUC = exports.SavePersistentStatesUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class SavePersistentStatesUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(SavePersistentStatesUC.type, appObjects);
+    }
+}
+exports.SavePersistentStatesUC = SavePersistentStatesUC;
+SavePersistentStatesUC.type = "SavePersistentStatesUC";
+function makeSavePersistentStatesUC(appObject) {
+    return new SavePersistentStatesUCImp(appObject);
+}
+exports.makeSavePersistentStatesUC = makeSavePersistentStatesUC;
+class SavePersistentStatesUCImp extends SavePersistentStatesUC {
+    constructor(appObject) {
+        super(appObject, SavePersistentStatesUC.type);
+        this.saveLocally = () => {
+            if (!this.stateMachine)
+                return;
+            const states = this.stateMachine.states;
+            const statesData = JSON.stringify(states);
+            const a = document.createElement("a");
+            const file = new Blob([statesData], { type: "text/plain" });
+            a.href = URL.createObjectURL(file);
+            a.download = "persistentStates.json";
+            a.click();
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get stateMachine() {
+        return this.getCachedSingleton(Entities_1.HostStateMachine.type);
+    }
+}

package/lib/Components/StateMachine/UCs/TransitionToState/TransitionToSandboxStateUC.d.ts

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

package/lib/Components/StateMachine/UCs/TransitionToState/TransitionToSandboxStateUC.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTransitionToSandboxStateUC = void 0;
+const Entities_1 = require("../../../AppSandbox/Entities");
+const Dispatcher_1 = require("../../../Dispatcher");
+const Entities_2 = require("../../Entities");
+const TransitionToStateUC_1 = require("./TransitionToStateUC");
+function makeTransitionToSandboxStateUC(appObject) {
+    return new TransitionToSandboxStateUCImp(appObject);
+}
+exports.makeTransitionToSandboxStateUC = makeTransitionToSandboxStateUC;
+class TransitionToSandboxStateUCImp extends TransitionToStateUC_1.TransitionToStateUC {
+    get sandbox() {
+        return this.getCachedSingleton(Entities_1.AppSandboxEntity.type);
+    }
+    get stateMachine() {
+        return this.getCachedSingleton(Entities_2.HostStateMachine.type);
+    }
+    transitionToState(id) {
+        if (!this.sandbox || !this.stateMachine)
+            return;
+        const dispatchSetState = Dispatcher_1.DispatchSetStateUC.getByID(this.sandbox.appID, this.appObjects);
+        if (!dispatchSetState) {
+            this.error("Unable to find DispatchSetStateUC");
+            return;
+        }
+        const stateMachine = this.stateMachine;
+        const state = this.stateMachine.getStateByID(id);
+        if (!state) {
+            this.warn(`Unable to find state ${id}`);
+            return;
+        }
+        stateMachine.setActiveStateByID(id);
+        const stateStr = JSON.stringify(state.stateData);
+        const duration = stateMachine.transitionDuration;
+        dispatchSetState.doDispatch(stateStr, duration);
+    }
+    constructor(appObject) {
+        super(appObject, TransitionToStateUC_1.TransitionToStateUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}

package/lib/Components/StateMachine/UCs/TransitionToState/TransitionToStateUC.d.ts

@@ -0,0 +1,6 @@
+import { HostAppObjectRepo, HostAppObjectUC } from "../../../../HostAppObject";
+export declare abstract class TransitionToStateUC extends HostAppObjectUC {
+    static type: string;
+    abstract transitionToState(id: string): void;
+    static get(appObjects: HostAppObjectRepo): TransitionToStateUC | undefined;
+}

package/lib/Components/StateMachine/UCs/TransitionToState/TransitionToStateUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransitionToStateUC = void 0;
+const HostAppObject_1 = require("../../../../HostAppObject");
+class TransitionToStateUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(TransitionToStateUC.type, appObjects);
+    }
+}
+exports.TransitionToStateUC = TransitionToStateUC;
+TransitionToStateUC.type = "TransitionToStateUC";

package/lib/Components/StateMachine/UCs/TransitionToState/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./TransitionToSandboxStateUC";
+export * from "./TransitionToStateUC";

package/lib/Components/StateMachine/UCs/TransitionToState/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("./TransitionToSandboxStateUC"), exports);
+__exportStar(require("./TransitionToStateUC"), exports);

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

@@ -1,2 +1,12 @@
+export * from "./CancelEditing";
+export * from "./ConsumeState";
 export * from "./DeleteStateUC";
 export * from "./DuplicateStateUC";
+export * from "./EditActiveState";
+export * from "./EditState";
+export * from "./EndActivity";
+export * from "./NewState";
+export * from "./SaveAuthoring";
+export * from "./SavePersistentStates";
+export * from "./setSandboxStatesFromData";
+export * from "./TransitionToState";

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

@@ -10,5 +10,15 @@ 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("./CancelEditing"), exports);
+__exportStar(require("./ConsumeState"), exports);
 __exportStar(require("./DeleteStateUC"), exports);
 __exportStar(require("./DuplicateStateUC"), exports);
+__exportStar(require("./EditActiveState"), exports);
+__exportStar(require("./EditState"), exports);
+__exportStar(require("./EndActivity"), exports);
+__exportStar(require("./NewState"), exports);
+__exportStar(require("./SaveAuthoring"), exports);
+__exportStar(require("./SavePersistentStates"), exports);
+__exportStar(require("./setSandboxStatesFromData"), exports);
+__exportStar(require("./TransitionToState"), exports);

package/lib/Components/StateMachine/UCs/setSandboxStatesFromData.d.ts

@@ -0,0 +1,7 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+export interface SandboxStateData {
+    id: string;
+    name: string;
+    data: object;
+}
+export declare function setSandboxStatesFromData(datas: SandboxStateData[], appObjects: HostAppObjectRepo): void;

package/lib/Components/StateMachine/UCs/setSandboxStatesFromData.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSandboxStatesFromData = void 0;
+const Entities_1 = require("../../AppSandbox/Entities");
+const Entities_2 = require("../Entities");
+function setSandboxStatesFromData(datas, appObjects) {
+    const stateMachine = Entities_2.HostStateMachine.get(appObjects);
+    if (!stateMachine) {
+        appObjects.submitError("setSandboxStatesFromData", "Unable to find StateMachineEntity");
+        return;
+    }
+    const sandbox = Entities_1.AppSandboxEntity.get(appObjects);
+    if (!sandbox) {
+        appObjects.submitWarning("setSandboxStatesFromData", "Could not find AppSandboxEntity");
+        return;
+    }
+    const states = [];
+    datas.forEach((stateData) => {
+        const { data, id, name } = stateData;
+        const state = stateMachine.stateFactory(id);
+        state.setStateData(data);
+        state.name = name;
+        state.appID = sandbox.appID;
+        states.push(state);
+    });
+    stateMachine.setStates(states);
+}
+exports.setSandboxStatesFromData = setSandboxStatesFromData;