@vived/host 3.0.0 → 3.2.0

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;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockHostStateEntity = exports.MockHostStateEntity = void 0;
+const Entities_1 = require("../Entities");
+class MockHostStateEntity extends Entities_1.HostStateEntity {
+    constructor(appObject) {
+        super(appObject, Entities_1.HostStateEntity.type);
+        this.name = "State Name";
+        this.assets = [];
+        this.expectedResponse = Entities_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/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./MockDeleteStateUC";
+export * from "./MockDuplicateStateUC";
+export * from "./MockHostEditingStateEntity";
+export * from "./MockHostStateMachinePM";
+export * from "./MockIsEditingStatePM";
+export * from "./MockStateEntity";

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

@@ -0,0 +1,18 @@
+"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("./MockDeleteStateUC"), exports);
+__exportStar(require("./MockDuplicateStateUC"), exports);
+__exportStar(require("./MockHostEditingStateEntity"), exports);
+__exportStar(require("./MockHostStateMachinePM"), exports);
+__exportStar(require("./MockIsEditingStatePM"), exports);
+__exportStar(require("./MockStateEntity"), exports);

package/lib/Components/StateMachine/PMs/EditingStatePM.d.ts

@@ -0,0 +1,19 @@
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from "../../../HostAppObject";
+export interface EditingStateVM {
+    isEditing: boolean;
+    isNewState: boolean;
+    hasChanges: boolean;
+}
+export declare const defaultIsEditingStateVM: EditingStateVM;
+export declare abstract class EditingStatePM extends HostAppObjectPM<EditingStateVM> {
+    static type: string;
+    static get(appObjects: HostAppObjectRepo): EditingStatePM | undefined;
+}
+export declare function makeEditingStatePM(appObject: HostAppObject): EditingStatePMImp;
+declare class EditingStatePMImp extends EditingStatePM {
+    private get editingEntity();
+    vmsAreEqual(a: EditingStateVM, b: EditingStateVM): boolean;
+    private onEntityChange;
+    constructor(appObject: HostAppObject);
+}
+export {};

package/lib/Components/StateMachine/PMs/EditingStatePM.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEditingStatePM = exports.EditingStatePM = exports.defaultIsEditingStateVM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+exports.defaultIsEditingStateVM = {
+    hasChanges: false,
+    isEditing: false,
+    isNewState: false
+};
+class EditingStatePM extends HostAppObject_1.HostAppObjectPM {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(EditingStatePM.type, appObjects);
+    }
+}
+exports.EditingStatePM = EditingStatePM;
+EditingStatePM.type = "EditingStatePM";
+function makeEditingStatePM(appObject) {
+    return new EditingStatePMImp(appObject);
+}
+exports.makeEditingStatePM = makeEditingStatePM;
+class EditingStatePMImp extends EditingStatePM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, EditingStatePM.type);
+        this.onEntityChange = () => {
+            if (!this.editingEntity)
+                return;
+            const isEditing = this.editingEntity.isEditing;
+            const isNewState = this.editingEntity.isNewState;
+            const hasChanges = this.editingEntity.somethingHasChanged;
+            this.doUpdateView({
+                isEditing,
+                isNewState,
+                hasChanges
+            });
+        };
+        (_a = this.editingEntity) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+        this.appObjects.registerSingleton(this);
+    }
+    get editingEntity() {
+        return this.getCachedSingleton(Entities_1.HostEditingStateEntity.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.isEditing !== b.isEditing)
+            return false;
+        if (a.isNewState !== b.isNewState)
+            return false;
+        if (a.hasChanges !== b.hasChanges)
+            return false;
+        return true;
+    }
+}

package/lib/Components/StateMachine/PMs/HostStateMachinePM.d.ts

@@ -0,0 +1,23 @@
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from "../../../HostAppObject";
+export interface HostStateMachineVM {
+    activeSlideID: string | undefined;
+    nextSlideID: string | undefined;
+    previousSlideID: string | undefined;
+    states: {
+        id: string;
+        name: string;
+    }[];
+}
+export declare abstract class HostStateMachinePM extends HostAppObjectPM<HostStateMachineVM> {
+    static type: string;
+    static get(appObjects: HostAppObjectRepo): HostStateMachinePM | undefined;
+}
+export declare function makeHostStateMachinePM(appObject: HostAppObject): HostStateMachinePMImp;
+declare class HostStateMachinePMImp extends HostStateMachinePM {
+    private stateMachine?;
+    vmsAreEqual(a: HostStateMachineVM, b: HostStateMachineVM): boolean;
+    private onEntityChange;
+    constructor(appObject: HostAppObject);
+}
+export declare const defaultHostStateMachineVM: HostStateMachineVM;
+export {};

package/lib/Components/StateMachine/PMs/HostStateMachinePM.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultHostStateMachineVM = exports.makeHostStateMachinePM = exports.HostStateMachinePM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class HostStateMachinePM extends HostAppObject_1.HostAppObjectPM {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(HostStateMachinePM.type, appObjects);
+    }
+}
+exports.HostStateMachinePM = HostStateMachinePM;
+HostStateMachinePM.type = "HostStateMachinePM";
+function makeHostStateMachinePM(appObject) {
+    return new HostStateMachinePMImp(appObject);
+}
+exports.makeHostStateMachinePM = makeHostStateMachinePM;
+class HostStateMachinePMImp extends HostStateMachinePM {
+    constructor(appObject) {
+        super(appObject, HostStateMachinePM.type);
+        this.onEntityChange = () => {
+            if (!this.stateMachine)
+                return;
+            const states = this.stateMachine.states.map((stateID) => {
+                var _a, _b, _c;
+                const name = (_c = (_b = (_a = this.stateMachine) === null || _a === void 0 ? void 0 : _a.getStateByID(stateID)) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : "";
+                return { id: stateID, name };
+            });
+            const vm = {
+                activeSlideID: this.stateMachine.activeState,
+                nextSlideID: this.stateMachine.nextState,
+                previousSlideID: this.stateMachine.previousState,
+                states
+            };
+            this.doUpdateView(vm);
+        };
+        this.stateMachine = appObject.getComponent(Entities_1.HostStateMachine.type);
+        if (!this.stateMachine) {
+            this.error("PM has been added to an App Object that does not have a HostStateMachine");
+            return;
+        }
+        this.stateMachine.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+        this.appObjects.registerSingleton(this);
+    }
+    vmsAreEqual(a, b) {
+        if (a.activeSlideID !== b.activeSlideID)
+            return false;
+        if (a.nextSlideID !== b.nextSlideID)
+            return false;
+        if (a.previousSlideID !== b.previousSlideID)
+            return false;
+        if (a.states.length !== b.states.length)
+            return false;
+        let statesAreEqual = true;
+        a.states.forEach((stateA, i) => {
+            const stateB = b.states[i];
+            if (stateA.id !== stateB.id)
+                statesAreEqual = false;
+            if (stateA.name !== stateB.name)
+                statesAreEqual = false;
+        });
+        return statesAreEqual;
+    }
+}
+exports.defaultHostStateMachineVM = {
+    activeSlideID: undefined,
+    nextSlideID: undefined,
+    previousSlideID: undefined,
+    states: []
+};

package/lib/Components/StateMachine/PMs/IsEditingStatePM.d.ts

@@ -0,0 +1,13 @@
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from "../../../HostAppObject";
+export declare abstract class IsEditingStatePM extends HostAppObjectPM<boolean> {
+    static type: string;
+    static get(appObjects: HostAppObjectRepo): IsEditingStatePM | undefined;
+}
+export declare function makeIsEditingStatePM(appObject: HostAppObject): IsEditingStatePMImp;
+declare class IsEditingStatePMImp extends IsEditingStatePM {
+    private get editingEntity();
+    vmsAreEqual(a: boolean, b: boolean): boolean;
+    private onEntityChange;
+    constructor(appObject: HostAppObject);
+}
+export {};

package/lib/Components/StateMachine/PMs/IsEditingStatePM.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIsEditingStatePM = exports.IsEditingStatePM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class IsEditingStatePM extends HostAppObject_1.HostAppObjectPM {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(IsEditingStatePM.type, appObjects);
+    }
+}
+exports.IsEditingStatePM = IsEditingStatePM;
+IsEditingStatePM.type = "IsEditingStatePM";
+function makeIsEditingStatePM(appObject) {
+    return new IsEditingStatePMImp(appObject);
+}
+exports.makeIsEditingStatePM = makeIsEditingStatePM;
+class IsEditingStatePMImp extends IsEditingStatePM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, IsEditingStatePM.type);
+        this.onEntityChange = () => {
+            if (!this.editingEntity)
+                return;
+            this.doUpdateView(this.editingEntity.isEditing);
+        };
+        (_a = this.editingEntity) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+        this.appObjects.registerSingleton(this);
+    }
+    get editingEntity() {
+        return this.getCachedSingleton(Entities_1.HostEditingStateEntity.type);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./HostStateMachinePM";
+export * from "./EditingStatePM";

package/lib/Components/StateMachine/PMs/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("./HostStateMachinePM"), exports);
+__exportStar(require("./EditingStatePM"), exports);

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

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

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDeleteStateUC = exports.DeleteStateUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class DeleteStateUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(DeleteStateUC.type, appObjects);
+    }
+}
+exports.DeleteStateUC = DeleteStateUC;
+DeleteStateUC.type = "DeleteStateUC";
+function makeDeleteStateUC(appObject) {
+    return new DeleteStateUCImp(appObject);
+}
+exports.makeDeleteStateUC = makeDeleteStateUC;
+class DeleteStateUCImp extends DeleteStateUC {
+    constructor(appObject) {
+        super(appObject, DeleteStateUC.type);
+        this.deleteState = (id) => {
+            if (!this.stateMachine)
+                return;
+            const state = this.stateMachine.getStateByID(id);
+            if (this.stateMachine.hasState(id)) {
+                this.stateMachine.deleteState(id);
+            }
+            else {
+                this.warn("Unable to find state to delete");
+                return;
+            }
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get stateMachine() {
+        return this.getCachedLocalComponent(Entities_1.HostStateMachine.type);
+    }
+}

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDuplicateStateUC = exports.DuplicateStateUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class DuplicateStateUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(DuplicateStateUC.type, appObjects);
+    }
+}
+exports.DuplicateStateUC = DuplicateStateUC;
+DuplicateStateUC.type = "DuplicateStateUC";
+function makeDuplicateStateUC(appObject) {
+    return new DuplicateStateUCImp(appObject);
+}
+exports.makeDuplicateStateUC = makeDuplicateStateUC;
+class DuplicateStateUCImp extends DuplicateStateUC {
+    constructor(appObject) {
+        super(appObject, DuplicateStateUC.type);
+        this.duplicateState = (id) => {
+            if (!this.stateMachine)
+                return;
+            const state = this.stateMachine.getStateByID(id);
+            if (!state) {
+                this.warn("Unable to find state to duplicate");
+                return;
+            }
+            const newState = this.stateMachine.createNewState();
+            const dto = state.getDTO();
+            dto.id = newState.id;
+            dto.name = dto.name + " Copy";
+            newState.setDTO(dto);
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get stateMachine() {
+        return this.getCachedLocalComponent(Entities_1.HostStateMachine.type);
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./DeleteStateUC";
+export * from "./DuplicateStateUC";

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

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

@@ -0,0 +1,6 @@
+export * from "./Adapters";
+export * from "./Controllers";
+export * from "./Entities";
+export * from "./Mocks";
+export * from "./PMs";
+export * from "./UCs";

package/lib/Components/StateMachine/index.js

@@ -0,0 +1,18 @@
+"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("./Adapters"), exports);
+__exportStar(require("./Controllers"), exports);
+__exportStar(require("./Entities"), exports);
+__exportStar(require("./Mocks"), exports);
+__exportStar(require("./PMs"), exports);
+__exportStar(require("./UCs"), exports);

package/lib/Components/index.d.ts

@@ -1,6 +1,9 @@
+export * from "./Apps";
+export * from "./AssetPlugin";
 export * from "./Assets";
 export * from "./Dialog";
 export * from "./Dispatcher";
 export * from "./Handler";
+export * from "./StateMachine";
 export * from "./VivedAPI";
 export * from "./ZSpaceHost";