@vived/host 3.0.0 → 3.1.0

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

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

@@ -0,0 +1,3 @@
+export * from "./HostEditingStateEntity";
+export * from "./HostStateEntity";
+export * from "./HostStateMachine";

package/lib/Components/StateMachine/Entities/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("./HostEditingStateEntity"), exports);
+__exportStar(require("./HostStateEntity"), exports);
+__exportStar(require("./HostStateMachine"), exports);

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

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockDeleteStateUC = exports.MockDeleteStateUC = void 0;
+const UCs_1 = require("../UCs");
+class MockDeleteStateUC extends UCs_1.DeleteStateUC {
+    constructor(appObject) {
+        super(appObject, UCs_1.DeleteStateUC.type);
+        this.deleteState = jest.fn();
+    }
+}
+exports.MockDeleteStateUC = MockDeleteStateUC;
+function makeMockDeleteStateUC(appObjects) {
+    return new MockDeleteStateUC(appObjects.getOrCreate("MockDeleteStateUC"));
+}
+exports.makeMockDeleteStateUC = makeMockDeleteStateUC;

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

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

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

@@ -0,0 +1,15 @@
+"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 {
+    constructor(appObject) {
+        super(appObject, UCs_1.DuplicateStateUC.type);
+        this.duplicateState = jest.fn();
+    }
+}
+exports.MockDuplicateStateUC = MockDuplicateStateUC;
+function makeMockDuplicateStateUC(appObjects) {
+    return new MockDuplicateStateUC(appObjects.getOrCreate("MockDuplicateStateUC"));
+}
+exports.makeMockDuplicateStateUC = makeMockDuplicateStateUC;

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

@@ -0,0 +1,16 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { HostEditingStateEntity, HostStateEntity } from "../Entities";
+export declare class MockHostEditingStateEntity extends HostEditingStateEntity {
+    get isNewState(): boolean;
+    get isEditing(): boolean;
+    get editingState(): HostStateEntity | undefined;
+    get somethingHasChanged(): boolean;
+    stateValidationMessage?: string | undefined;
+    startNewState: jest.Mock<any, any>;
+    startEditing: jest.Mock<any, any>;
+    cancelEditState: jest.Mock<any, any>;
+    finishEditing: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockHostEditingStateEntity(appObjects: HostAppObjectRepo): MockHostEditingStateEntity;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockHostEditingStateEntity = exports.MockHostEditingStateEntity = void 0;
+const Entities_1 = require("../Entities");
+class MockHostEditingStateEntity extends Entities_1.HostEditingStateEntity {
+    constructor(appObject) {
+        super(appObject, Entities_1.HostEditingStateEntity.type);
+        this.startNewState = jest.fn();
+        this.startEditing = jest.fn();
+        this.cancelEditState = jest.fn();
+        this.finishEditing = jest.fn();
+    }
+    get isNewState() {
+        throw new Error("Method not implemented.");
+    }
+    get isEditing() {
+        throw new Error("Method not implemented.");
+    }
+    get editingState() {
+        throw new Error("Method not implemented.");
+    }
+    get somethingHasChanged() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MockHostEditingStateEntity = MockHostEditingStateEntity;
+function makeMockHostEditingStateEntity(appObjects) {
+    return new MockHostEditingStateEntity(appObjects.getOrCreate("MockHostEditingStateEntity"));
+}
+exports.makeMockHostEditingStateEntity = makeMockHostEditingStateEntity;

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

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

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

@@ -0,0 +1,15 @@
+"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 {
+    constructor(appObject) {
+        super(appObject, PMs_1.HostStateMachinePM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.MockHostStateMachinePM = MockHostStateMachinePM;
+function makeMockHostStateMachinePM(appObjects) {
+    return new MockHostStateMachinePM(appObjects.getOrCreate("MockHostStateMachinePM"));
+}
+exports.makeMockHostStateMachinePM = makeMockHostStateMachinePM;

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

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

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

@@ -0,0 +1,15 @@
+"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 {
+    constructor(appObject) {
+        super(appObject, PMs_1.EditingStatePM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.MockIsEditingStatePM = MockIsEditingStatePM;
+function makeMockIsEditingStatePM(appObjects) {
+    return new MockIsEditingStatePM(appObjects.getOrCreate("MockIsEditingStatePM"));
+}
+exports.makeMockIsEditingStatePM = makeMockIsEditingStatePM;

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

@@ -0,0 +1,16 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { ChallengeResponse, HostStateEntity } from "../Entities";
+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;