@vived/app 3.9.1 → 4.0.0

package/lib/Entities/SceneModel.js

@@ -1,202 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSceneModel = exports.SceneModel = exports.SceneModelState = void 0;
-const ValueObjects_1 = require("../ValueObjects");
-const MemoizedNumber_1 = require("./Memoized/MemoizedNumber");
-const MemoizedQuaternion_1 = require("./Memoized/MemoizedQuaternion");
-const MemoizedString_1 = require("./Memoized/MemoizedString");
-const MemoizedVector3_1 = require("./Memoized/MemoizedVector3");
-const ObservableEntity_1 = require("./ObservableEntity");
-const SceneModelMesh_1 = require("./SceneModelMesh");
-var SceneModelState;
-(function (SceneModelState) {
-    SceneModelState["INIT"] = "Initialized";
-    SceneModelState["LOADING"] = "Loading";
-    SceneModelState["READY"] = "Ready";
-    SceneModelState["ERROR"] = "Error";
-})(SceneModelState = exports.SceneModelState || (exports.SceneModelState = {}));
-class SceneModel extends ObservableEntity_1.ObservableEntity {
-}
-exports.SceneModel = SceneModel;
-function makeSceneModel(id) {
-    return new SceneModelImp(id);
-}
-exports.makeSceneModel = makeSceneModel;
-class SceneModelImp extends SceneModel {
-    constructor(id) {
-        super();
-        this._name = new MemoizedString_1.MemoizedString("", this.notify);
-        this._boundsMin = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
-        this._boundsMax = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
-        this._defaultPosition = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
-        this._defaultRotation = new MemoizedQuaternion_1.MemoizedQuaternion(ValueObjects_1.Quaternion.Identity(), this.notify);
-        this._defaultScale = new MemoizedNumber_1.MemoizedNumber(1, this.notify);
-        this._state = new MemoizedString_1.MemoizedString(SceneModelState.INIT, this.notify);
-        this.sceneModelObjectLookup = new Map();
-        this.hasMesh = (id) => {
-            return this.sceneModelObjectLookup.has(id);
-        };
-        this.getMeshById = (id) => {
-            return this.sceneModelObjectLookup.get(id);
-        };
-        this.getMeshByPath = (path) => {
-            let rVal;
-            this.sceneModelObjectLookup.forEach((sceneModelObject) => {
-                if (sceneModelObject.hasMeshPath(path)) {
-                    rVal = sceneModelObject;
-                }
-            });
-            return rVal;
-        };
-        this.addMesh = (object) => {
-            if (this.sceneModelObjectLookup.has(object.id)) {
-                const orig = this.sceneModelObjectLookup.get(object.id);
-                orig === null || orig === void 0 ? void 0 : orig.removeObserver(this.notify);
-            }
-            this.sceneModelObjectLookup.set(object.id, object);
-            object.addObserver(this.notify);
-            this.notify();
-        };
-        this.removeMesh = (id) => {
-            const orig = this.sceneModelObjectLookup.get(id);
-            if (orig) {
-                this.sceneModelObjectLookup.delete(id);
-                orig.removeObserver(this.notify);
-                this.notify();
-            }
-        };
-        this.getAllMeshes = () => {
-            return Array.from(this.sceneModelObjectLookup.values());
-        };
-        this.applyData = (data) => {
-            if (data.version === 0) {
-                this.applyDataV0(data);
-            }
-            else if (data.version === 1) {
-                this.applyDataV1(data);
-            }
-            else {
-                throw new Error(`applyData unsupported version number: ${data.version}`);
-            }
-        };
-        this.toData = () => {
-            const data = {
-                version: 1,
-                bounds_max: this.bounds_max.dto,
-                bounds_min: this.bounds_min.dto,
-                defaultPosition: this.defaultPosition.dto,
-                defaultRotation: this.defaultRotation.dto,
-                defaultScale: this.defaultScale,
-                name: this.name,
-                objects: this.getAllMeshes().map((obj) => obj.toData()),
-            };
-            return data;
-        };
-        this.id = id;
-    }
-    get name() {
-        return this._name.val;
-    }
-    set name(name) {
-        this._name.val = name;
-    }
-    get bounds_min() {
-        return this._boundsMin.val;
-    }
-    set bounds_min(bounds_min) {
-        this._boundsMin.val = bounds_min;
-    }
-    get bounds_max() {
-        return this._boundsMax.val;
-    }
-    set bounds_max(bounds_max) {
-        this._boundsMax.val = bounds_max;
-    }
-    get defaultPosition() {
-        return this._defaultPosition.val;
-    }
-    set defaultPosition(position) {
-        this._defaultPosition.val = position;
-    }
-    get defaultRotation() {
-        return this._defaultRotation.val;
-    }
-    set defaultRotation(rotation) {
-        this._defaultRotation.val = rotation;
-    }
-    get defaultScale() {
-        return this._defaultScale.val;
-    }
-    set defaultScale(scale) {
-        this._defaultScale.val = scale;
-    }
-    get state() {
-        return this._state.val;
-    }
-    set state(val) {
-        this._state.val = val;
-    }
-    get error() {
-        return this._error;
-    }
-    set error(val) {
-        this._error = val;
-        this._state.val = SceneModelState.ERROR;
-    }
-    applyDataV0(data) {
-        this._name.setValQuietly(data.name);
-        this._boundsMin.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_min));
-        this._boundsMax.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_max));
-        this._defaultPosition.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.defaultPosition));
-        this._defaultScale.setValQuietly(data.defaultScale);
-        this._defaultRotation.setValQuietly(ValueObjects_1.Quaternion.FromDTO(data.defaultRotation));
-        const objectsToKeep = [];
-        data.objects.forEach((objectDTO) => {
-            const existingObj = this.sceneModelObjectLookup.get(objectDTO.id);
-            if (existingObj) {
-                existingObj.applyData(objectDTO);
-            }
-            else {
-                const newObj = SceneModelMesh_1.makeSceneModelMesh(objectDTO.id);
-                newObj.applyData(objectDTO);
-                this.addMesh(newObj);
-            }
-            objectsToKeep.push(objectDTO.id);
-        });
-        const allObjects = Array.from(this.sceneModelObjectLookup.keys());
-        allObjects.forEach((obj) => {
-            if (!objectsToKeep.includes(obj)) {
-                this.removeMesh(obj);
-            }
-        });
-        this.notify();
-    }
-    applyDataV1(data) {
-        this._name.setValQuietly(data.name);
-        this._boundsMin.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_min));
-        this._boundsMax.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_max));
-        this._defaultPosition.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.defaultPosition));
-        this._defaultScale.setValQuietly(data.defaultScale);
-        this._defaultRotation.setValQuietly(ValueObjects_1.Quaternion.FromDTO(data.defaultRotation));
-        const objectsToKeep = [];
-        data.objects.forEach((objectDTO) => {
-            const existingObj = this.sceneModelObjectLookup.get(objectDTO.id);
-            if (existingObj) {
-                existingObj.applyData(objectDTO);
-            }
-            else {
-                const newObj = SceneModelMesh_1.makeSceneModelMesh(objectDTO.id);
-                newObj.applyData(objectDTO);
-                this.addMesh(newObj);
-            }
-            objectsToKeep.push(objectDTO.id);
-        });
-        const allObjects = Array.from(this.sceneModelObjectLookup.keys());
-        allObjects.forEach((obj) => {
-            if (!objectsToKeep.includes(obj)) {
-                this.removeMesh(obj);
-            }
-        });
-        this.notify();
-    }
-}

package/lib/Entities/SceneModelMesh.d.ts

@@ -1,40 +0,0 @@
-import { ObservableEntity } from "./ObservableEntity";
-export declare abstract class SceneModelMesh extends ObservableEntity {
-    abstract readonly id: string;
-    abstract label: string;
-    abstract meshPaths: string[];
-    abstract addMeshPath(path: string): void;
-    abstract hasMeshPath(path: string): boolean;
-    abstract removeMeshPath(path: string): void;
-    abstract toData(): SceneModelObjectDTO;
-    abstract applyData(data: SceneModelObjectDTO): void;
-}
-export declare function makeSceneModelMesh(id: string): SceneModelMeshImp;
-declare class SceneModelMeshImp extends SceneModelMesh {
-    readonly id: string;
-    private _meshPaths;
-    get meshPaths(): string[];
-    set meshPaths(paths: string[]);
-    private memoizedLabel;
-    get label(): string;
-    set label(val: string);
-    addMeshPath: (path: string) => void;
-    hasMeshPath: (path: string) => boolean;
-    removeMeshPath: (path: string) => void;
-    toData: () => SceneModelObjectDTO;
-    applyData: (data: SceneModelObjectDTO) => void;
-    constructor(id: string);
-}
-export declare type SceneModelObjectDTO = SceneModelObjectDTOv0 | SceneModelObjectDTOv1;
-export interface SceneModelObjectDTOv1 {
-    version: number;
-    id: string;
-    meshPaths: string[];
-    label: string;
-}
-export interface SceneModelObjectDTOv0 {
-    id: string;
-    meshPaths: string[];
-    label: string;
-}
-export {};

package/lib/Entities/SceneModelMesh.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSceneModelMesh = exports.SceneModelMesh = void 0;
-const MemoizedString_1 = require("./Memoized/MemoizedString");
-const ObservableEntity_1 = require("./ObservableEntity");
-class SceneModelMesh extends ObservableEntity_1.ObservableEntity {
-}
-exports.SceneModelMesh = SceneModelMesh;
-function makeSceneModelMesh(id) {
-    return new SceneModelMeshImp(id);
-}
-exports.makeSceneModelMesh = makeSceneModelMesh;
-class SceneModelMeshImp extends SceneModelMesh {
-    constructor(id) {
-        super();
-        this._meshPaths = [];
-        this.memoizedLabel = new MemoizedString_1.MemoizedString("", this.notify);
-        this.addMeshPath = (path) => {
-            if (this._meshPaths.includes(path))
-                return;
-            this._meshPaths.push(path);
-            this.notify();
-        };
-        this.hasMeshPath = (path) => {
-            return this._meshPaths.includes(path);
-        };
-        this.removeMeshPath = (path) => {
-            const index = this._meshPaths.indexOf(path);
-            if (index >= 0) {
-                this._meshPaths.splice(index, 1);
-                this.notify();
-            }
-        };
-        this.toData = () => {
-            const dto = {
-                version: 1,
-                id: this.id,
-                label: this.label,
-                meshPaths: [...this._meshPaths],
-            };
-            return dto;
-        };
-        this.applyData = (data) => {
-            this.label = data.label;
-            this.meshPaths = data.meshPaths;
-        };
-        this.id = id;
-    }
-    get meshPaths() {
-        return [...this._meshPaths];
-    }
-    set meshPaths(paths) {
-        let pathsHaveChanged = false;
-        if (paths.length !== this._meshPaths.length) {
-            pathsHaveChanged = true;
-        }
-        else {
-            paths.forEach((path, i) => {
-                if (path !== this._meshPaths[i]) {
-                    pathsHaveChanged = true;
-                }
-            });
-        }
-        if (!pathsHaveChanged)
-            return;
-        this._meshPaths = paths;
-        this.notify();
-    }
-    get label() {
-        return this.memoizedLabel.val;
-    }
-    set label(val) {
-        this.memoizedLabel.val = val;
-    }
-}

package/lib/Entities/SceneModelRepo.d.ts

@@ -1,11 +0,0 @@
-import { ObservableEntityRepo } from "./ObservableEntityRepo";
-import { SceneModel, SceneModelDTO } from "./SceneModel";
-export declare abstract class SceneModelRepo extends ObservableEntityRepo<SceneModel> {
-    abstract get activeModel(): SceneModel | undefined;
-    abstract activeModelID: string;
-    abstract isLoadingSceneModel: boolean;
-    abstract modelLoader(modelID: string): Promise<void>;
-    abstract dataLoader(dataID: string): Promise<SceneModelDTO>;
-    abstract clearActiveModel(): void;
-}
-export declare function makeSceneModelRepo(): SceneModelRepo;

package/lib/Entities/SceneModelRepo.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSceneModelRepo = exports.SceneModelRepo = void 0;
-const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
-const MemoizedString_1 = require("./Memoized/MemoizedString");
-const ObservableEntityRepo_1 = require("./ObservableEntityRepo");
-class SceneModelRepo extends ObservableEntityRepo_1.ObservableEntityRepo {
-}
-exports.SceneModelRepo = SceneModelRepo;
-function makeSceneModelRepo() {
-    return new SceneModelRepoImp();
-}
-exports.makeSceneModelRepo = makeSceneModelRepo;
-class SceneModelRepoImp extends SceneModelRepo {
-    constructor() {
-        super(...arguments);
-        this.memoizedActiveModelID = new MemoizedString_1.MemoizedString("", this.notify);
-        this.memoizedIsLoading = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
-    }
-    modelLoader( /*modelID: string*/) {
-        return Promise.reject(new Error(`SceneModelRepo function modelLoader has not been injected`));
-    }
-    dataLoader( /*dataID: string*/) {
-        return Promise.reject(new Error(`SceneModelRepo function dataLoader has not been injected`));
-    }
-    get activeModelID() {
-        return this.memoizedActiveModelID.val;
-    }
-    set activeModelID(id) {
-        if (!this.has(id)) {
-            console.warn("[SceneModelRepo] Unknown Model ID ", id);
-            return;
-        }
-        this.memoizedActiveModelID.val = id;
-    }
-    get isLoadingSceneModel() {
-        return this.memoizedIsLoading.val;
-    }
-    set isLoadingSceneModel(val) {
-        this.memoizedIsLoading.val = val;
-    }
-    clearActiveModel() {
-        this.memoizedActiveModelID.val = "";
-    }
-    get activeModel() {
-        return this.get(this.memoizedActiveModelID.val);
-    }
-}

package/lib/Entities/SceneObject.d.ts

@@ -1,23 +0,0 @@
-import { ObservableEntity } from "./ObservableEntity";
-import { TransformNode } from "./TransformNode";
-export declare abstract class SceneObject extends ObservableEntity {
-    abstract readonly id: string;
-    abstract get shown(): boolean;
-    abstract set shown(shown: boolean);
-    abstract get enabled(): boolean;
-    abstract set enabled(enabled: boolean);
-    abstract get selected(): boolean;
-    abstract set selected(selected: boolean);
-    abstract get hovered(): boolean;
-    abstract set hovered(hovered: boolean);
-    abstract get pressed(): boolean;
-    abstract set pressed(pressed: boolean);
-    abstract get defaultLabel(): string;
-    abstract set defaultLabel(defaultLabel: string);
-    abstract get customLabel(): string;
-    abstract set customLabel(customLabel: string);
-    abstract get validationMessage(): string | null;
-    abstract transform: TransformNode;
-    abstract sceneTransform: unknown;
-}
-export declare function makeSceneObject(id: string): SceneObject;

package/lib/Entities/SceneObject.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSceneObject = exports.SceneObject = void 0;
-const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
-const MemoizedString_1 = require("./Memoized/MemoizedString");
-const ObservableEntity_1 = require("./ObservableEntity");
-const TransformNode_1 = require("./TransformNode");
-class SceneObject extends ObservableEntity_1.ObservableEntity {
-}
-exports.SceneObject = SceneObject;
-function makeSceneObject(id) {
-    return new SceneObjectImp(id);
-}
-exports.makeSceneObject = makeSceneObject;
-class SceneObjectImp extends SceneObject {
-    constructor(id) {
-        super();
-        this.memoizedDefaultLabel = new MemoizedString_1.MemoizedString("", this.notify);
-        this.memoizedCustomLabel = new MemoizedString_1.MemoizedString("", this.notify);
-        this.memoizedShown = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
-        this.memoizedEnabled = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
-        this.memoizedSelected = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
-        this.memoizedHovered = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
-        this.memoizedPressed = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
-        this.transform = TransformNode_1.makeTransformNode();
-        this.id = id;
-        this.transform.addObserver(this.notify);
-    }
-    get defaultLabel() {
-        return this.memoizedDefaultLabel.val;
-    }
-    set defaultLabel(defaultLabel) {
-        this.memoizedDefaultLabel.val = defaultLabel;
-    }
-    get customLabel() {
-        return this.memoizedCustomLabel.val;
-    }
-    set customLabel(customLabel) {
-        this.memoizedCustomLabel.val = customLabel;
-    }
-    get validationMessage() {
-        if (this.customLabel.length > 40) {
-            return "Object labels are limited to 40 characters";
-        }
-        else {
-            return null;
-        }
-    }
-    get shown() {
-        return this.memoizedShown.val;
-    }
-    set shown(shown) {
-        this.memoizedShown.val = shown;
-    }
-    get enabled() {
-        return this.memoizedEnabled.val;
-    }
-    set enabled(enabled) {
-        this.memoizedEnabled.val = enabled;
-    }
-    get selected() {
-        return this.memoizedSelected.val;
-    }
-    set selected(selected) {
-        this.memoizedSelected.val = selected;
-    }
-    get hovered() {
-        return this.memoizedHovered.val;
-    }
-    set hovered(hovered) {
-        this.memoizedHovered.val = hovered;
-    }
-    get pressed() {
-        return this.memoizedPressed.val;
-    }
-    set pressed(pressed) {
-        this.memoizedPressed.val = pressed;
-    }
-}

package/lib/Entities/SceneObjectsRepo.d.ts

@@ -1,12 +0,0 @@
-import { ObservableEntityRepo } from "./ObservableEntityRepo";
-import { SceneObject } from "./SceneObject";
-export declare abstract class SceneObjectsRepo extends ObservableEntityRepo<SceneObject> {
-    abstract get pressedSceneObject(): string | null;
-    abstract set pressedSceneObject(sceneObjectId: string | null);
-    abstract get hoveredSceneObject(): string | null;
-    abstract set hoveredSceneObject(sceneObjectId: string | null);
-    abstract unselectAllSceneObjects: () => void;
-    abstract getSelectedSceneObjects: () => SceneObject[];
-    abstract selectSceneObject: (id: string) => void;
-}
-export declare function makeSceneObjectRepo(): SceneObjectsRepo;

package/lib/Entities/SceneObjectsRepo.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSceneObjectRepo = exports.SceneObjectsRepo = void 0;
-const ObservableEntityRepo_1 = require("./ObservableEntityRepo");
-class SceneObjectsRepo extends ObservableEntityRepo_1.ObservableEntityRepo {
-}
-exports.SceneObjectsRepo = SceneObjectsRepo;
-function makeSceneObjectRepo() {
-    return new SceneObjectsRepoImp();
-}
-exports.makeSceneObjectRepo = makeSceneObjectRepo;
-class SceneObjectsRepoImp extends SceneObjectsRepo {
-    constructor() {
-        super(...arguments);
-        this._pressedSceneObject = null;
-        this._hoveredSceneObject = null;
-        this.unselectAllSceneObjects = () => {
-            this.getAll().forEach(sceneObject => {
-                sceneObject.selected = false;
-            });
-        };
-        this.getSelectedSceneObjects = () => {
-            const selectedObjects = [];
-            this.getAll().forEach(sceneObject => {
-                if (sceneObject.selected) {
-                    selectedObjects.push(sceneObject);
-                }
-            });
-            return selectedObjects;
-        };
-        this.selectSceneObject = (id) => {
-            const sceneObject = this.get(id);
-            if (sceneObject) {
-                sceneObject.selected = true;
-            }
-        };
-    }
-    get pressedSceneObject() {
-        return this._pressedSceneObject;
-    }
-    set pressedSceneObject(sceneObjectId) {
-        if (sceneObjectId === this._pressedSceneObject) {
-            return;
-        }
-        this._pressedSceneObject = sceneObjectId;
-        this.notify();
-    }
-    get hoveredSceneObject() {
-        return this._hoveredSceneObject;
-    }
-    set hoveredSceneObject(sceneObjectId) {
-        if (sceneObjectId === this._hoveredSceneObject) {
-            return;
-        }
-        this._hoveredSceneObject = sceneObjectId;
-        this.notify();
-    }
-}

package/lib/Entities/StateMachine.d.ts

@@ -1,29 +0,0 @@
-import { Result } from "../ValueObjects";
-export declare type OnStateHasBeenApplied = () => void;
-export interface SerializedStates {
-    version: number;
-    systems: SystemState[];
-}
-export interface SystemState {
-    name: string;
-    seriliziationVersion: number;
-    state: object;
-}
-export interface SerializedSystem {
-    name: string;
-    seriliziationVersion: number;
-    getSystemState(): object;
-    applySystemState(state: object, version: number, transitionDuration: number): void;
-    applyDefaultState(transitionDuration: number): void;
-}
-export interface StateMachine {
-    transitionEaseFunction: (normalizedTime: number) => number;
-    getSerializedStates(): SerializedStates;
-    setSerializedStates(state: SerializedStates, transitionTime: number): Result<null, Error>;
-    applySerializedStatesString: (state: string, duration?: number) => void;
-    setDefaultState(transitionTime: number): void;
-    registerSerializedSystem(serializedSystem: SerializedSystem): Result<null, Error>;
-    addStateHasBeenAppliedObserver: (observer: OnStateHasBeenApplied) => void;
-    removeStateHasBeenAppliedObserver: (observer: OnStateHasBeenApplied) => void;
-}
-export declare function makeStateMachine(): StateMachine;

package/lib/Entities/StateMachine.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeStateMachine = void 0;
-const ValueObjects_1 = require("../ValueObjects");
-const ObserverList_1 = require("./ObserverList");
-function makeStateMachine() {
-    return new StateMachineImp();
-}
-exports.makeStateMachine = makeStateMachine;
-class StateMachineImp {
-    constructor() {
-        this.serializedSystems = new Map();
-        this.serilizationVersion = 2;
-        this.stateAppliedObservers = new ObserverList_1.ObserverList();
-        this.transitionEaseFunction = (normalizedTime) => {
-            return normalizedTime; // default to a linear function
-        };
-        this.applySerializedStatesString = (state, duration = 0) => {
-            if (state === "") {
-                this.setDefaultState(duration);
-            }
-            else {
-                try {
-                    const stateObj = JSON.parse(state);
-                    this.setSerializedStates(stateObj, duration);
-                }
-                catch (e) {
-                    this.setDefaultState(duration);
-                    console.warn("[StateMachine] Failed to deserialize state string: " + e);
-                }
-            }
-        };
-        this.registerSerializedSystem = (serializedSystem) => {
-            if (this.serializedSystems.has(serializedSystem.name)) {
-                const err = new Error(`[StateMachine] Duplicate stateable systems encountered: ${serializedSystem.name}`);
-                console.error(err.message);
-                return ValueObjects_1.reject(err);
-            }
-            this.serializedSystems.set(serializedSystem.name, serializedSystem);
-            return ValueObjects_1.resolve(null);
-        };
-        this.getSerializedStates = () => {
-            const systems = Array.from(this.serializedSystems.values());
-            const serializedStates = systems.map((system) => {
-                const state = system.getSystemState();
-                return {
-                    seriliziationVersion: system.seriliziationVersion,
-                    name: system.name,
-                    state,
-                };
-            });
-            return {
-                version: this.serilizationVersion,
-                systems: serializedStates,
-            };
-        };
-        this.setSerializedStates = (state, duration) => {
-            if (state.version === 2) {
-                const appliedToSystems = [];
-                state.systems.forEach((systemState) => {
-                    const seriliazableSystem = this.serializedSystems.get(systemState.name);
-                    if (seriliazableSystem) {
-                        seriliazableSystem.applySystemState(systemState.state, systemState.seriliziationVersion, duration);
-                    }
-                    else {
-                        console.warn("Unable to find seriarializedSystem " + systemState.name);
-                    }
-                    appliedToSystems.push(systemState.name);
-                });
-                this.serializedSystems.forEach((system) => {
-                    if (!appliedToSystems.includes(system.name)) {
-                        system.applyDefaultState(duration);
-                    }
-                });
-                this.stateAppliedObservers.notify();
-                return ValueObjects_1.resolve(null);
-            }
-            // Here is where we will add support for future versions
-            else {
-                const err = new Error(`[StateMachine] Unsupported sereialized state encountered: ${state.version}`);
-                console.error(err.message);
-                return ValueObjects_1.reject(err);
-            }
-        };
-        this.setDefaultState = (duration) => {
-            this.serializedSystems.forEach((system) => {
-                system.applyDefaultState(duration);
-            });
-            this.stateAppliedObservers.notify();
-        };
-        this.addStateHasBeenAppliedObserver = (observer) => {
-            this.stateAppliedObservers.add(observer);
-        };
-        this.removeStateHasBeenAppliedObserver = (observer) => {
-            this.stateAppliedObservers.remove(observer);
-        };
-    }
-}