@vived/host 3.0.0 → 3.2.0

package/lib/Components/Handler/UCs/RegisterExternalStyleSheetsHandler.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeRegisterExternalStyleSheetsHandler = exports.RegisterExternalStyleSheetsHandler = void 0;
 const HostAppObject_1 = require("../../../HostAppObject");
+const Apps_1 = require("../../Apps");
 const Entities_1 = require("../Entities");
 class RegisterExternalStyleSheetsHandler extends HostAppObject_1.HostAppObjectUC {
     constructor() {
@@ -20,7 +21,13 @@ class RegisterExternalStyleSheetsHandlerImp extends RegisterExternalStyleSheetsH
         super(appObject, RegisterExternalStyleSheetsHandler.type);
         this.requestType = "REGISTER_EXTERNAL_STYLESHEETS";
         this.action = (stylesheets) => {
-            this.log(`Style sheets: ${stylesheets}`);
+            if (!this.app)
+                return;
+            stylesheets.forEach((sheet) => {
+                var _a;
+                (_a = this.app) === null || _a === void 0 ? void 0 : _a.styles.push(sheet);
+            });
+            this.app.notifyOnChange();
         };
         this.handleRequest = (version, payload) => {
             if (version === 1) {
@@ -38,6 +45,9 @@ class RegisterExternalStyleSheetsHandlerImp extends RegisterExternalStyleSheetsH
         }
         hostHandler.registerRequestHandler(this);
     }
+    get app() {
+        return this.getCachedLocalComponent(Apps_1.AppEntity.type);
+    }
     castPayloadV1(payload) {
         const castPayload = payload;
         if (castPayload.stylesheets === undefined) {

package/lib/Components/StateMachine/Adapters/hostStateMachinePMAdapter.d.ts

@@ -0,0 +1,3 @@
+import { SingletonPmAdapter } from "../../../Types/SingletonPmAdapter";
+import { HostStateMachineVM } from "../PMs";
+export declare const hostStateMachinePMAdapter: SingletonPmAdapter<HostStateMachineVM>;

package/lib/Components/StateMachine/Adapters/hostStateMachinePMAdapter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hostStateMachinePMAdapter = void 0;
+const PMs_1 = require("../PMs");
+exports.hostStateMachinePMAdapter = {
+    defaultVM: PMs_1.defaultHostStateMachineVM,
+    subscribe: (appObjects, setVM) => {
+        const pm = PMs_1.HostStateMachinePM.get(appObjects);
+        if (!pm) {
+            appObjects.submitError("hostStateMachinePMAdapter", "Unable to find HostStateMachinePM");
+            return;
+        }
+        pm.addView(setVM);
+    },
+    unsubscribe: (appObjects, setVM) => {
+        const pm = PMs_1.HostStateMachinePM.get(appObjects);
+        if (!pm) {
+            appObjects.submitError("hostStateMachinePMAdapter", "Unable to find HostStateMachinePM");
+            return;
+        }
+        pm.removeView(setVM);
+    }
+};

package/lib/Components/StateMachine/Adapters/hostStateMachinePMAdater.d.ts

@@ -0,0 +1,3 @@
+import { ReactHookPmAdapter } from "../../../Types/ReactHookPmAdapter";
+import { HostStateMachineVM } from "../PMs";
+export declare const hostStateMachinePMAdapter: ReactHookPmAdapter<HostStateMachineVM>;

package/lib/Components/StateMachine/Adapters/hostStateMachinePMAdater.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hostStateMachinePMAdapter = void 0;
+const PMs_1 = require("../PMs");
+exports.hostStateMachinePMAdapter = {
+    defaultVM: PMs_1.defaultHostStateMachineVM,
+    subscribe: (appObjects, setVM) => {
+        const pm = PMs_1.HostStateMachinePM.get(appObjects);
+        if (!pm) {
+            appObjects.submitError("hostStateMachinePMAdater", "Unable to find HostStateMachinePM");
+            return;
+        }
+        pm.addView(setVM);
+    },
+    unsubscribe: (appObjects, setVM) => {
+        const pm = PMs_1.HostStateMachinePM.get(appObjects);
+        if (!pm) {
+            appObjects.submitError("hostStateMachinePMAdater", "Unable to find HostStateMachinePM");
+            return;
+        }
+        pm.removeView(setVM);
+    }
+};

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

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

package/lib/Components/StateMachine/Adapters/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("./hostStateMachinePMAdapter"), exports);

package/lib/Components/StateMachine/Adapters/isEditingPMAdapter.d.ts

@@ -0,0 +1,3 @@
+import { ReactHookPmAdapter } from "../../../Types/ReactHookPmAdapter";
+import { EditingStateVM } from "../PMs";
+export declare const isEditingPMAdapter: ReactHookPmAdapter<EditingStateVM>;

package/lib/Components/StateMachine/Adapters/isEditingPMAdapter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEditingPMAdapter = void 0;
+const PMs_1 = require("../PMs");
+exports.isEditingPMAdapter = {
+    defaultVM: PMs_1.defaultIsEditingStateVM,
+    subscribe: (appObjects, setVM) => {
+        const pm = PMs_1.EditingStatePM.get(appObjects);
+        if (!pm) {
+            appObjects.submitError("isEditingPMAdapter", "Unable to find HostStateMachinePM");
+            return;
+        }
+        pm.addView(setVM);
+    },
+    unsubscribe: (appObjects, setVM) => {
+        const pm = PMs_1.EditingStatePM.get(appObjects);
+        if (!pm) {
+            appObjects.submitError("isEditingPMAdapter", "Unable to find HostStateMachinePM");
+            return;
+        }
+        pm.removeView(setVM);
+    }
+};

package/lib/Components/StateMachine/Controllers/deleteState.d.ts

@@ -0,0 +1,2 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+export declare function deleteState(id: string, appObjects: HostAppObjectRepo): void;

package/lib/Components/StateMachine/Controllers/deleteState.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteState = void 0;
+const UCs_1 = require("../UCs");
+function deleteState(id, appObjects) {
+    const uc = UCs_1.DeleteStateUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("duplicateState", "Unable to find DeleteStateUC");
+        return;
+    }
+    uc.deleteState(id);
+}
+exports.deleteState = deleteState;

package/lib/Components/StateMachine/Controllers/duplicateState.d.ts

@@ -0,0 +1,2 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+export declare function duplicateState(id: string, appObjects: HostAppObjectRepo): void;

package/lib/Components/StateMachine/Controllers/duplicateState.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.duplicateState = void 0;
+const UCs_1 = require("../UCs");
+function duplicateState(id, appObjects) {
+    const uc = UCs_1.DuplicateStateUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("duplicateState", "Unable to find DuplicateStateUC");
+        return;
+    }
+    uc.duplicateState(id);
+}
+exports.duplicateState = duplicateState;

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

@@ -0,0 +1,2 @@
+export * from "./deleteState";
+export * from "./duplicateState";

package/lib/Components/StateMachine/Controllers/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("./deleteState"), exports);
+__exportStar(require("./duplicateState"), exports);

package/lib/Components/StateMachine/Entities/HostEditingStateEntity.d.ts

@@ -0,0 +1,16 @@
+import { HostAppObject, HostAppObjectEntity, HostAppObjectRepo } from "../../../HostAppObject";
+import { HostStateEntity } from "./HostStateEntity";
+export declare abstract class HostEditingStateEntity extends HostAppObjectEntity {
+    static type: string;
+    abstract get isEditing(): boolean;
+    abstract get isNewState(): boolean;
+    abstract get editingState(): HostStateEntity | undefined;
+    abstract get somethingHasChanged(): boolean;
+    abstract stateValidationMessage?: string;
+    abstract startNewState(): HostStateEntity | undefined;
+    abstract startEditing(state: HostStateEntity): void;
+    abstract cancelEditState(): void;
+    abstract finishEditing(): void;
+    static get(appObjects: HostAppObjectRepo): HostEditingStateEntity | undefined;
+}
+export declare function makeHostEditingStateEntity(appObject: HostAppObject): HostEditingStateEntity;

package/lib/Components/StateMachine/Entities/HostEditingStateEntity.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHostEditingStateEntity = exports.HostEditingStateEntity = void 0;
+const Entities_1 = require("../../../Entities");
+const HostAppObject_1 = require("../../../HostAppObject");
+const HostStateMachine_1 = require("./HostStateMachine");
+class HostEditingStateEntity extends HostAppObject_1.HostAppObjectEntity {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(HostEditingStateEntity.type, appObjects);
+    }
+}
+exports.HostEditingStateEntity = HostEditingStateEntity;
+HostEditingStateEntity.type = "HostEditingStateEntity";
+function makeHostEditingStateEntity(appObject) {
+    return new HostEditingStateEntityImp(appObject);
+}
+exports.makeHostEditingStateEntity = makeHostEditingStateEntity;
+class HostEditingStateEntityImp extends HostEditingStateEntity {
+    constructor(appObject) {
+        super(appObject, HostEditingStateEntity.type);
+        this._isNewState = false;
+        this.memoizedSomethingHasChanged = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.checkForChange = () => {
+            var _a, _b;
+            if (!this._editingState)
+                return false;
+            if (!this.originalStateData)
+                return true;
+            if (this._editingState.name !== this.originalStateData.name)
+                return true;
+            if (this._editingState.expectedResponse !== this.originalStateData.response)
+                return true;
+            if (this._editingState.assets.length !== this.originalStateData.assets.length)
+                return true;
+            let assetsHaveChanged = false;
+            this._editingState.assets.forEach((currentAssetID, i) => {
+                const originalAssetId = this.originalStateData.assets[i];
+                if (originalAssetId !== currentAssetID) {
+                    assetsHaveChanged = true;
+                }
+            });
+            if (assetsHaveChanged) {
+                return true;
+            }
+            const currentDataString = JSON.stringify(this._editingState.stateData);
+            const originalData = JSON.stringify((_b = (_a = this.originalStateData) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : "");
+            if (currentDataString !== originalData)
+                return true;
+            return false;
+        };
+        this.onStateEntityChange = () => {
+            this.memoizedSomethingHasChanged.val = this.checkForChange();
+        };
+        this.startNewState = () => {
+            if (!this.hostStateMachine)
+                return;
+            this.originalStateData = undefined;
+            this._isNewState = true;
+            this._editingState = this.hostStateMachine.createNewState();
+            this._editingState.addChangeObserver(this.onStateEntityChange);
+            this.memoizedSomethingHasChanged.val = true;
+            return this._editingState;
+        };
+        this.startEditing = (state) => {
+            this._editingState = state;
+            this.originalStateData = state.getDTO();
+            this._editingState.addChangeObserver(this.onStateEntityChange);
+            this.notifyOnChange();
+        };
+        this.cancelEditState = () => {
+            var _a;
+            if (!this._editingState)
+                return;
+            if (this.originalStateData) {
+                this._editingState.setDTO(this.originalStateData);
+            }
+            else {
+                (_a = this.hostStateMachine) === null || _a === void 0 ? void 0 : _a.deleteState(this._editingState.id);
+            }
+            this.resetInternalState();
+        };
+        this.finishEditing = () => {
+            this.resetInternalState();
+        };
+        this.resetInternalState = () => {
+            if (!this._editingState)
+                return;
+            this._isNewState = false;
+            this._editingState.removeChangeObserver(this.onStateEntityChange);
+            this._stateValidationMessage = undefined;
+            this._editingState = undefined;
+            this.memoizedSomethingHasChanged.val = false;
+            this.notifyOnChange();
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get isNewState() {
+        return this._isNewState;
+    }
+    get stateValidationMessage() {
+        return this._stateValidationMessage;
+    }
+    set stateValidationMessage(val) {
+        if (this._stateValidationMessage === val)
+            return;
+        this._stateValidationMessage = val;
+        this.notifyOnChange();
+    }
+    get hostStateMachine() {
+        return this.getCachedSingleton(HostStateMachine_1.HostStateMachine.type);
+    }
+    get somethingHasChanged() {
+        return this.memoizedSomethingHasChanged.val;
+    }
+    get isEditing() {
+        return this._editingState !== undefined;
+    }
+    get editingState() {
+        return this._editingState;
+    }
+}

package/lib/Components/StateMachine/Entities/HostStateEntity.d.ts

@@ -0,0 +1,31 @@
+import { HostAppObject, HostAppObjectEntity, HostAppObjectRepo } from "../../../HostAppObject";
+export declare enum ChallengeResponse {
+    NONE = "NONE",
+    SCORE = "SCORE",
+    HIT = "HIT",
+    MULTIHIT = "MULTIHIT",
+    PROGRESS = "PROGRESS",
+    QUALITY = "QUALITY"
+}
+export interface StateDTO {
+    id: string;
+    name: string;
+    data: object;
+    assets: string[];
+    response: string | undefined;
+    appID: string;
+}
+export declare abstract class HostStateEntity extends HostAppObjectEntity {
+    static type: string;
+    abstract get id(): string;
+    abstract name: string;
+    abstract assets: string[];
+    abstract expectedResponse: ChallengeResponse | undefined;
+    abstract appID: string;
+    abstract getDTO(): StateDTO;
+    abstract setDTO(dto: StateDTO): void;
+    abstract get stateData(): object;
+    abstract setStateData(val: object, checkForChange?: boolean): void;
+    static get(id: string, appObjects: HostAppObjectRepo): HostStateEntity | undefined;
+}
+export declare function makeHostStateEntity(appObject: HostAppObject): HostStateEntity;

package/lib/Components/StateMachine/Entities/HostStateEntity.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHostStateEntity = exports.HostStateEntity = exports.ChallengeResponse = void 0;
+const Entities_1 = require("../../../Entities");
+const HostAppObject_1 = require("../../../HostAppObject");
+var ChallengeResponse;
+(function (ChallengeResponse) {
+    ChallengeResponse["NONE"] = "NONE";
+    ChallengeResponse["SCORE"] = "SCORE";
+    ChallengeResponse["HIT"] = "HIT";
+    ChallengeResponse["MULTIHIT"] = "MULTIHIT";
+    ChallengeResponse["PROGRESS"] = "PROGRESS";
+    ChallengeResponse["QUALITY"] = "QUALITY";
+})(ChallengeResponse = exports.ChallengeResponse || (exports.ChallengeResponse = {}));
+class HostStateEntity extends HostAppObject_1.HostAppObjectEntity {
+    static get(id, appObjects) {
+        const ao = appObjects.get(id);
+        return ao === null || ao === void 0 ? void 0 : ao.getComponent(HostStateEntity.type);
+    }
+}
+exports.HostStateEntity = HostStateEntity;
+HostStateEntity.type = "HostStateEntity";
+function makeHostStateEntity(appObject) {
+    return new HostStateEntityImp(appObject);
+}
+exports.makeHostStateEntity = makeHostStateEntity;
+class HostStateEntityImp extends HostStateEntity {
+    constructor(appObject) {
+        super(appObject, HostStateEntity.type);
+        this.memoizedName = new Entities_1.MemoizedString("", this.notifyOnChange);
+        this._data = {};
+        this._assets = [];
+        this.memoisedAppID = new Entities_1.MemoizedString("", this.notifyOnChange);
+    }
+    get id() {
+        return this.appObject.id;
+    }
+    get name() {
+        return this.memoizedName.val;
+    }
+    set name(val) {
+        this.memoizedName.val = val;
+    }
+    get stateData() {
+        return this._data;
+    }
+    setStateData(val, checkForChange) {
+        let notify = true;
+        if (checkForChange) {
+            const currentData = JSON.stringify(this._data);
+            const newData = JSON.stringify(val);
+            if (currentData === newData) {
+                notify = false;
+            }
+        }
+        this._data = val;
+        if (notify) {
+            this.notifyOnChange();
+        }
+    }
+    get assets() {
+        return [...this._assets];
+    }
+    set assets(val) {
+        if (val.length !== this._assets.length) {
+            this._assets = val;
+            this.notifyOnChange();
+            return;
+        }
+        let somethingHasChanged = false;
+        val.forEach((newAsset, i) => {
+            const existingAsset = this._assets[i];
+            if (existingAsset !== newAsset) {
+                somethingHasChanged = true;
+            }
+        });
+        if (!somethingHasChanged) {
+            return;
+        }
+        this._assets = val;
+        this.notifyOnChange();
+    }
+    get expectedResponse() {
+        return this._expectedResponse;
+    }
+    set expectedResponse(val) {
+        if (val === this._expectedResponse)
+            return;
+        this._expectedResponse = val;
+        this.notifyOnChange();
+    }
+    getDTO() {
+        return {
+            id: this.id,
+            assets: [...this._assets],
+            data: this._data,
+            name: this.memoizedName.val,
+            response: this._expectedResponse,
+            appID: this.appID
+        };
+    }
+    setDTO(dto) {
+        if (dto.id !== this.id) {
+            this.warn("DTO id does not match my ID. Skipping");
+            return;
+        }
+        this.setStateData(dto.data, true);
+        this.assets = [...dto.assets];
+        this.memoizedName.val = dto.name;
+        this.memoisedAppID.val = dto.appID;
+        if (Object.values(ChallengeResponse).includes(dto.response)) {
+            this.expectedResponse = dto.response;
+        }
+        else {
+            this.expectedResponse = undefined;
+        }
+    }
+    get appID() {
+        return this.memoisedAppID.val;
+    }
+    set appID(val) {
+        this.memoisedAppID.val = val;
+    }
+}

package/lib/Components/StateMachine/Entities/HostStateMachine.d.ts

@@ -0,0 +1,20 @@
+import { HostAppObject, HostAppObjectEntity, HostAppObjectRepo } from "../../../HostAppObject";
+import { HostStateEntity } from "./HostStateEntity";
+export declare abstract class HostStateMachine extends HostAppObjectEntity {
+    static type: string;
+    abstract states: string[];
+    abstract activeState: string | undefined;
+    abstract previousState: string | undefined;
+    abstract nextState: string | undefined;
+    abstract setActiveStateByID: (id: string) => void;
+    abstract clearActiveState: () => void;
+    abstract setStates: (states: HostStateEntity[]) => void;
+    abstract createNewState: () => HostStateEntity;
+    abstract getStateByID: (id: string) => HostStateEntity | undefined;
+    abstract deleteState: (id: string) => void;
+    abstract getStateIndex: (id: string) => number | undefined;
+    abstract hasState: (id: string) => boolean;
+    abstract stateFactory: (id: string) => HostStateEntity;
+    static get(appObjects: HostAppObjectRepo): HostStateMachine | undefined;
+}
+export declare function makeHostStateMachine(appObject: HostAppObject): HostStateMachine;

package/lib/Components/StateMachine/Entities/HostStateMachine.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHostStateMachine = exports.HostStateMachine = void 0;
+const Entities_1 = require("../../../Entities");
+const HostAppObject_1 = require("../../../HostAppObject");
+const Utilities_1 = require("../../../Utilities");
+const HostStateEntity_1 = require("./HostStateEntity");
+class HostStateMachine extends HostAppObject_1.HostAppObjectEntity {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(HostStateMachine.type, appObjects);
+    }
+}
+exports.HostStateMachine = HostStateMachine;
+HostStateMachine.type = "HostStateMachine";
+function makeHostStateMachine(appObject) {
+    return new HostStateMachineImp(appObject);
+}
+exports.makeHostStateMachine = makeHostStateMachine;
+class HostStateMachineImp extends HostStateMachine {
+    constructor(appObject) {
+        super(appObject, HostStateMachine.type);
+        this._states = [];
+        this.memoizedIsAuthoring = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this._lastAssets = [];
+        this.hasState = (id) => {
+            const state = this.findStateByID(id);
+            if (state) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        this.setActiveStateByID = (id) => {
+            const state = this.findStateByID(id);
+            if (!state)
+                return;
+            if (state.id === this._activeState)
+                return;
+            this._activeState = state.id;
+            const index = this.getStateIndex(id);
+            if (index === undefined) {
+                this._nextState = undefined;
+                this._previousState = undefined;
+                return;
+            }
+            const prevIndex = index - 1;
+            const nextIndex = index + 1;
+            if (prevIndex >= 0) {
+                this._previousState = this._states[prevIndex].id;
+            }
+            else {
+                this._previousState = undefined;
+            }
+            if (nextIndex < this._states.length) {
+                this._nextState = this._states[nextIndex].id;
+            }
+            else {
+                this._nextState = undefined;
+            }
+            this.notifyOnChange();
+        };
+        this.clearActiveState = () => {
+            if (!this.activeState)
+                return;
+            this._nextState = undefined;
+            this._previousState = undefined;
+            this._activeState = undefined;
+            this.notifyOnChange();
+        };
+        this.setStates = (states) => {
+            this._states = states;
+            this.notifyOnChange();
+        };
+        this.stateFactory = (id) => {
+            const ao = this.appObjects.getOrCreate(id);
+            return HostStateEntity_1.makeHostStateEntity(ao);
+        };
+        this.createNewState = () => {
+            const newState = this.stateFactory(Utilities_1.generateUniqueID());
+            this._states.push(newState);
+            this.notifyOnChange();
+            return newState;
+        };
+        this.getStateByID = (id) => {
+            return this.findStateByID(id);
+        };
+        this.deleteState = (id) => {
+            const index = this.getStateIndex(id);
+            if (index === undefined) {
+                return;
+            }
+            const state = this.getStateByID(id);
+            state === null || state === void 0 ? void 0 : state.appObject.dispose();
+            this._states.splice(index, 1);
+            this.notifyOnChange();
+        };
+        this.getStateIndex = (id) => {
+            let index = -1;
+            this._states.forEach((state, i) => {
+                if (state.id === id) {
+                    index = i;
+                }
+            });
+            if (index >= 0) {
+                return index;
+            }
+            else {
+                return undefined;
+            }
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get states() {
+        return this._states.map((state) => state.id);
+    }
+    get activeState() {
+        return this._activeState;
+    }
+    get previousState() {
+        return this._previousState;
+    }
+    get nextState() {
+        return this._nextState;
+    }
+    get isAuthoring() {
+        return this.memoizedIsAuthoring.val;
+    }
+    set isAuthoring(val) {
+        this.memoizedIsAuthoring.val = val;
+    }
+    get lastEditingState() {
+        return this._lastEditingState;
+    }
+    set lastEditingState(val) {
+        if (this._lastEditingState === undefined && val === undefined)
+            return;
+        const lastStateStr = this.lastEditingState === undefined
+            ? ""
+            : JSON.stringify(this.lastEditingState);
+        const valStateStr = val === undefined ? "" : JSON.stringify(val);
+        if (lastStateStr === valStateStr)
+            return;
+        this._lastEditingState = val;
+        this.notifyOnChange();
+    }
+    get lastAssets() {
+        return this._lastAssets;
+    }
+    set lastAssets(lastAssets) {
+        this._lastAssets = lastAssets;
+    }
+    findStateByID(id) {
+        for (const state of this._states) {
+            if (state.id === id) {
+                return state;
+            }
+        }
+        return undefined;
+    }
+}