@vived/host 3.8.0 → 3.9.1

package/lib/Components/StateMachine/Mocks/MockDuplicateStateUC.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="jest" />
 import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
-import { DuplicateStateUC } from "../UCs";
+import { DuplicateStateUC } from "../UCs/DuplicateStateUC";
 export declare class MockDuplicateStateUC extends DuplicateStateUC {
     duplicateState: jest.Mock<any, any>;
     constructor(appObject: HostAppObject);

package/lib/Components/StateMachine/Mocks/MockDuplicateStateUC.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeMockDuplicateStateUC = exports.MockDuplicateStateUC = void 0;
-const UCs_1 = require("../UCs");
-class MockDuplicateStateUC extends UCs_1.DuplicateStateUC {
+const DuplicateStateUC_1 = require("../UCs/DuplicateStateUC");
+class MockDuplicateStateUC extends DuplicateStateUC_1.DuplicateStateUC {
     constructor(appObject) {
-        super(appObject, UCs_1.DuplicateStateUC.type);
+        super(appObject, DuplicateStateUC_1.DuplicateStateUC.type);
         this.duplicateState = jest.fn();
     }
 }

package/lib/Components/StateMachine/Mocks/MockEditActiveStateUC.d.ts

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

package/lib/Components/StateMachine/Mocks/MockEditActiveStateUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockEditActiveStateUC = exports.MockEditActiveStateUC = void 0;
+const EditActiveStateUC_1 = require("../UCs/EditActiveState/EditActiveStateUC");
+class MockEditActiveStateUC extends EditActiveStateUC_1.EditActiveStateUC {
+    constructor(appObject) {
+        super(appObject, EditActiveStateUC_1.EditActiveStateUC.type);
+        this.editActiveState = jest.fn();
+    }
+}
+exports.MockEditActiveStateUC = MockEditActiveStateUC;
+function makeMockEditActiveStateUC(appObjects) {
+    return new MockEditActiveStateUC(appObjects.getOrCreate("MockEditActiveStateUC"));
+}
+exports.makeMockEditActiveStateUC = makeMockEditActiveStateUC;

package/lib/Components/StateMachine/Mocks/MockHostStateEntity.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { ChallengeResponse, HostStateEntity } from "../Entities/HostStateEntity";
+export declare class MockHostStateEntity extends HostStateEntity {
+    get id(): string;
+    name: string;
+    assets: never[];
+    expectedResponse: ChallengeResponse;
+    appID: string;
+    getDTO: jest.Mock<any, any>;
+    setDTO: jest.Mock<any, any>;
+    get stateData(): object;
+    setStateData: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockHostStateEntity(id: string, appObjects: HostAppObjectRepo): MockHostStateEntity;

package/lib/Components/StateMachine/Mocks/MockHostStateEntity.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockHostStateEntity = exports.MockHostStateEntity = void 0;
+const HostStateEntity_1 = require("../Entities/HostStateEntity");
+class MockHostStateEntity extends HostStateEntity_1.HostStateEntity {
+    constructor(appObject) {
+        super(appObject, HostStateEntity_1.HostStateEntity.type);
+        this.name = "State Name";
+        this.assets = [];
+        this.expectedResponse = HostStateEntity_1.ChallengeResponse.NONE;
+        this.appID = "AppID";
+        this.getDTO = jest.fn();
+        this.setDTO = jest.fn();
+        this.setStateData = jest.fn();
+    }
+    get id() {
+        return this.appObject.id;
+    }
+    get stateData() {
+        return { foo: "bar" };
+    }
+}
+exports.MockHostStateEntity = MockHostStateEntity;
+function makeMockHostStateEntity(id, appObjects) {
+    return new MockHostStateEntity(appObjects.getOrCreate(id));
+}
+exports.makeMockHostStateEntity = makeMockHostStateEntity;

package/lib/Components/StateMachine/Mocks/MockHostStateMachinePM.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="jest" />
 import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
-import { HostStateMachinePM } from "../PMs";
+import { HostStateMachinePM } from "../PMs/HostStateMachinePM";
 export declare class MockHostStateMachinePM extends HostStateMachinePM {
     vmsAreEqual: jest.Mock<any, any>;
     constructor(appObject: HostAppObject);

package/lib/Components/StateMachine/Mocks/MockHostStateMachinePM.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeMockHostStateMachinePM = exports.MockHostStateMachinePM = void 0;
-const PMs_1 = require("../PMs");
-class MockHostStateMachinePM extends PMs_1.HostStateMachinePM {
+const HostStateMachinePM_1 = require("../PMs/HostStateMachinePM");
+class MockHostStateMachinePM extends HostStateMachinePM_1.HostStateMachinePM {
     constructor(appObject) {
-        super(appObject, PMs_1.HostStateMachinePM.type);
+        super(appObject, HostStateMachinePM_1.HostStateMachinePM.type);
         this.vmsAreEqual = jest.fn();
     }
 }

package/lib/Components/StateMachine/Mocks/MockIsEditingStatePM.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="jest" />
 import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
-import { EditingStatePM } from "../PMs";
+import { EditingStatePM } from "../PMs/EditingStatePM";
 export declare class MockIsEditingStatePM extends EditingStatePM {
     vmsAreEqual: jest.Mock<any, any>;
     constructor(appObject: HostAppObject);

package/lib/Components/StateMachine/Mocks/MockIsEditingStatePM.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeMockIsEditingStatePM = exports.MockIsEditingStatePM = void 0;
-const PMs_1 = require("../PMs");
-class MockIsEditingStatePM extends PMs_1.EditingStatePM {
+const EditingStatePM_1 = require("../PMs/EditingStatePM");
+class MockIsEditingStatePM extends EditingStatePM_1.EditingStatePM {
     constructor(appObject) {
-        super(appObject, PMs_1.EditingStatePM.type);
+        super(appObject, EditingStatePM_1.EditingStatePM.type);
         this.vmsAreEqual = jest.fn();
     }
 }

package/lib/Components/StateMachine/Mocks/MockSaveAuthoringUC.d.ts

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

package/lib/Components/StateMachine/Mocks/MockSaveAuthoringUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockSaveAuthoringUC = exports.MockSaveAuthoringUC = void 0;
+const SaveAuthoringUC_1 = require("../UCs/SaveAuthoring/SaveAuthoringUC");
+class MockSaveAuthoringUC extends SaveAuthoringUC_1.SaveAuthoringUC {
+    constructor(appObject) {
+        super(appObject, SaveAuthoringUC_1.SaveAuthoringUC.type);
+        this.saveAuthoring = jest.fn();
+    }
+}
+exports.MockSaveAuthoringUC = MockSaveAuthoringUC;
+function makeMockSaveAuthoringUC(appObjects) {
+    return new MockSaveAuthoringUC(appObjects.getOrCreate("MockSaveAuthoringUC"));
+}
+exports.makeMockSaveAuthoringUC = makeMockSaveAuthoringUC;

package/lib/Components/StateMachine/Mocks/MockTransitionToStateUC.d.ts

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

package/lib/Components/StateMachine/Mocks/MockTransitionToStateUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockTransitionToStateUC = exports.MockTransitionToStateUC = void 0;
+const TransitionToStateUC_1 = require("../UCs/TransitionToState/TransitionToStateUC");
+class MockTransitionToStateUC extends TransitionToStateUC_1.TransitionToStateUC {
+    constructor(appObject) {
+        super(appObject, TransitionToStateUC_1.TransitionToStateUC.type);
+        this.transitionToState = jest.fn();
+    }
+}
+exports.MockTransitionToStateUC = MockTransitionToStateUC;
+function makeMockTransitionToStateUC(appObjects) {
+    return new MockTransitionToStateUC(appObjects.getOrCreate("MockTransitionToStateUC"));
+}
+exports.makeMockTransitionToStateUC = makeMockTransitionToStateUC;

package/lib/Components/StateMachine/Mocks/NewStateUCMock.d.ts

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

package/lib/Components/StateMachine/Mocks/NewStateUCMock.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNewStateUCMock = exports.NewStateUCMock = void 0;
+const NewStateUC_1 = require("../UCs/NewState/NewStateUC");
+class NewStateUCMock extends NewStateUC_1.NewStateUC {
+    constructor(appObject) {
+        super(appObject, NewStateUC_1.NewStateUC.type);
+        this.createState = jest.fn();
+    }
+}
+exports.NewStateUCMock = NewStateUCMock;
+function makeNewStateUCMock(appObjects) {
+    return new NewStateUCMock(appObjects.getOrCreate("NewStateUCMock"));
+}
+exports.makeNewStateUCMock = makeNewStateUCMock;

package/lib/Components/StateMachine/Mocks/SavePersistentStatesMock.d.ts

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

package/lib/Components/StateMachine/Mocks/SavePersistentStatesMock.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSavePersistentStatesMock = exports.SavePersistentStatesMock = void 0;
+const SavePersistentStates_1 = require("../UCs/SavePersistentStates");
+class SavePersistentStatesMock extends SavePersistentStates_1.SavePersistentStatesUC {
+    constructor(appObject) {
+        super(appObject, SavePersistentStates_1.SavePersistentStatesUC.type);
+        this.saveLocally = jest.fn();
+    }
+}
+exports.SavePersistentStatesMock = SavePersistentStatesMock;
+function makeSavePersistentStatesMock(appObjects) {
+    return new SavePersistentStatesMock(appObjects.getOrCreate("SavePersistentStatesMock"));
+}
+exports.makeSavePersistentStatesMock = makeSavePersistentStatesMock;

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

@@ -1,6 +1,15 @@
+export * from "./CancelEditingUCMock";
+export * from "./ConsumeStateUCMock";
+export * from "./EditStateUCMock";
+export * from "./EndActivityUCMock";
 export * from "./MockDeleteStateUC";
 export * from "./MockDuplicateStateUC";
+export * from "./MockEditActiveStateUC";
 export * from "./MockHostEditingStateEntity";
 export * from "./MockHostStateMachinePM";
 export * from "./MockIsEditingStatePM";
-export * from "./MockStateEntity";
+export * from "./MockSaveAuthoringUC";
+export * from "./MockHostStateEntity";
+export * from "./MockTransitionToStateUC";
+export * from "./NewStateUCMock";
+export * from "./SavePersistentStatesMock";

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

@@ -10,9 +10,18 @@ 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("./CancelEditingUCMock"), exports);
+__exportStar(require("./ConsumeStateUCMock"), exports);
+__exportStar(require("./EditStateUCMock"), exports);
+__exportStar(require("./EndActivityUCMock"), exports);
 __exportStar(require("./MockDeleteStateUC"), exports);
 __exportStar(require("./MockDuplicateStateUC"), exports);
+__exportStar(require("./MockEditActiveStateUC"), exports);
 __exportStar(require("./MockHostEditingStateEntity"), exports);
 __exportStar(require("./MockHostStateMachinePM"), exports);
 __exportStar(require("./MockIsEditingStatePM"), exports);
-__exportStar(require("./MockStateEntity"), exports);
+__exportStar(require("./MockSaveAuthoringUC"), exports);
+__exportStar(require("./MockHostStateEntity"), exports);
+__exportStar(require("./MockTransitionToStateUC"), exports);
+__exportStar(require("./NewStateUCMock"), exports);
+__exportStar(require("./SavePersistentStatesMock"), exports);

package/lib/Components/StateMachine/UCs/CancelEditing/CancelEditingUC.d.ts

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

package/lib/Components/StateMachine/UCs/CancelEditing/CancelEditingUC.js

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

package/lib/Components/StateMachine/UCs/CancelEditing/CancelSandboxEditingUC.d.ts

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

package/lib/Components/StateMachine/UCs/CancelEditing/CancelSandboxEditingUC.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCancelSandboxEditingUC = void 0;
+const Entities_1 = require("../../../AppSandbox/Entities");
+const Dispatcher_1 = require("../../../Dispatcher");
+const Entities_2 = require("../../Entities");
+const CancelEditingUC_1 = require("./CancelEditingUC");
+function makeCancelSandboxEditingUC(appObject) {
+    return new CancelSandboxEditingUC(appObject);
+}
+exports.makeCancelSandboxEditingUC = makeCancelSandboxEditingUC;
+class CancelSandboxEditingUC extends CancelEditingUC_1.CancelEditingUC {
+    constructor(appObject) {
+        super(appObject, CancelEditingUC_1.CancelEditingUC.type);
+        this.cancel = () => {
+            if (!this.sandbox || !this.stateMachine || !this.editStateEntity)
+                return;
+            const dispatchIsAuthoring = Dispatcher_1.DispatchIsAuthoringUC.getByID(this.sandbox.appID, this.appObjects);
+            if (!dispatchIsAuthoring) {
+                this.error("App does not have DispatchIsAuthoringUC");
+                return;
+            }
+            const dispatchSetState = Dispatcher_1.DispatchSetStateUC.getByID(this.sandbox.appID, this.appObjects);
+            if (!dispatchSetState) {
+                this.error("App does not have DispatchSetStateUC");
+                return;
+            }
+            this.editStateEntity.cancelEditState();
+            dispatchIsAuthoring.doDispatch(false);
+            if (this.stateMachine.activeState) {
+                const state = this.stateMachine.getStateByID(this.stateMachine.activeState);
+                if (state) {
+                    const stateData = JSON.stringify(state.stateData);
+                    dispatchSetState.doDispatch(stateData);
+                }
+            }
+            else {
+                this.sandbox.state = Entities_1.SandboxState.MOUNTED;
+            }
+        };
+        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/CancelEditing/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./CancelEditingUC";
+export * from "./CancelSandboxEditingUC";

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

package/lib/Components/StateMachine/UCs/ConsumeState/ConsumeSandboxStateUC.d.ts

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

package/lib/Components/StateMachine/UCs/ConsumeState/ConsumeSandboxStateUC.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeConsumeSandboxStateUC = void 0;
+const Entities_1 = require("../../../AppSandbox/Entities");
+const UCs_1 = require("../../../ZSpaceHost/UCs");
+const Entities_2 = require("../../Entities");
+const ConsumeStateUC_1 = require("./ConsumeStateUC");
+function makeConsumeSandboxStateUC(appObj) {
+    return new ConsumeSandboxStateUC(appObj);
+}
+exports.makeConsumeSandboxStateUC = makeConsumeSandboxStateUC;
+class ConsumeSandboxStateUC extends ConsumeStateUC_1.ConsumeStateUC {
+    constructor(appObject) {
+        super(appObject, ConsumeStateUC_1.ConsumeStateUC.type);
+        this.consume = (id) => {
+            var _a;
+            if (!this.sandbox ||
+                !this.stateMachine ||
+                !this.editStateEntity ||
+                !this.startZSpaceUC) {
+                this.error("Missing component");
+                return;
+            }
+            this.editStateEntity.cancelEditState();
+            if (this.stateMachine.hasState(id)) {
+                (_a = this.stateMachine) === null || _a === void 0 ? void 0 : _a.setActiveStateByID(id);
+                if (this.sandbox)
+                    this.sandbox.state = Entities_1.SandboxState.PLAYING;
+                if (this.sandbox.startInZSpace) {
+                    this.startZSpaceUC.startZSpace();
+                }
+            }
+            else {
+                this.error("Unable to find state by id " + id);
+            }
+        };
+        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);
+    }
+    get startZSpaceUC() {
+        return this.getCachedSingleton(UCs_1.StartZSpaceUC.type);
+    }
+}

package/lib/Components/StateMachine/UCs/ConsumeState/ConsumeStateUC.d.ts

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

package/lib/Components/StateMachine/UCs/ConsumeState/ConsumeStateUC.js

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

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

@@ -0,0 +1,2 @@
+export * from "./ConsumeSandboxStateUC";
+export * from "./ConsumeStateUC";

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

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

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

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;
+}