@vived/host 3.0.0 → 3.1.0

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

@@ -2,5 +2,6 @@ export * from "./Assets";
 export * from "./Dialog";
 export * from "./Dispatcher";
 export * from "./Handler";
+export * from "./StateMachine";
 export * from "./VivedAPI";
 export * from "./ZSpaceHost";

package/lib/Components/index.js

@@ -14,5 +14,6 @@ __exportStar(require("./Assets"), exports);
 __exportStar(require("./Dialog"), exports);
 __exportStar(require("./Dispatcher"), exports);
 __exportStar(require("./Handler"), exports);
+__exportStar(require("./StateMachine"), exports);
 __exportStar(require("./VivedAPI"), exports);
 __exportStar(require("./ZSpaceHost"), exports);

package/lib/Types/ReactHookPmAdapter.d.ts

@@ -0,0 +1,6 @@
+import { HostAppObjectRepo } from "../HostAppObject";
+export interface ReactHookPmAdapter<VM> {
+    defaultVM: VM;
+    subscribe(appObjects: HostAppObjectRepo, setVM: (vm: VM) => void): void;
+    unsubscribe(appObjects: HostAppObjectRepo, setVM: (vm: VM) => void): void;
+}

package/lib/Types/ReactHookPmAdapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/index.d.ts

@@ -1 +1,2 @@
 export * from './PluginBoundary';
+export * from "./ReactHookPmAdapter";

package/lib/Types/index.js

@@ -11,3 +11,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./PluginBoundary"), exports);
+__exportStar(require("./ReactHookPmAdapter"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/host",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Public Host package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",