@vived/app 3.9.1 → 4.0.0

package/lib/Components/SceneRoot/UC/PinchSceneRoot.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePinchSceneRootUC = exports.PinchSceneRootUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRootEntity_1 = require("../Entities/SceneRootEntity");
+class PinchSceneRootUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.PinchSceneRootUC = PinchSceneRootUC;
+PinchSceneRootUC.type = "PinchSceneRootUC";
+PinchSceneRootUC.get = (appObjects) => AppObject_1.getSingletonComponent(PinchSceneRootUC.type, appObjects);
+function makePinchSceneRootUC(appObject) {
+    return new PinchSceneRootImp(appObject);
+}
+exports.makePinchSceneRootUC = makePinchSceneRootUC;
+class PinchSceneRootImp extends PinchSceneRootUC {
+    constructor(appObject) {
+        super(appObject, PinchSceneRootUC.type);
+        this.sensitivity = 0.01;
+        this.previousDistanceBetweenTouches = 0;
+        this.panPlane = ValueObjects_1.ParametricPlane.XY();
+        this.pickOffset = ValueObjects_1.Vector3.Zero();
+        this.initialScale = 0;
+        this.initializePinch = (touchPos1, touchPos2) => {
+            var _a, _b;
+            if (!this.sceneRoot)
+                return;
+            const transformNode = this.sceneRoot.transform;
+            this.previousDistanceBetweenTouches = this.getTouchDistance(touchPos1, touchPos2);
+            const touchCenter = this.getTouchCenter(touchPos1, touchPos2);
+            const scenePick = Babylon_1.scenePixelPick(touchCenter, this.appObjects);
+            const pickPoint = (_a = scenePick === null || scenePick === void 0 ? void 0 : scenePick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            const pickPlaneDirection = ValueObjects_1.Vector3.Backward();
+            this.panPlane = ValueObjects_1.ParametricPlane.FromPointNormal(pickPoint, pickPlaneDirection);
+            const pickRay = Babylon_1.pixelToSceneRay(touchCenter, this.appObjects);
+            const planePick = (_b = this.panPlane.intersectLine(pickRay)) !== null && _b !== void 0 ? _b : ValueObjects_1.Vector3.Zero();
+            this.pickOffset = transformNode.worldPointToLocal(planePick);
+            this.initialScale = this.sceneRoot.scale;
+        };
+        this.doPinch = (touchPos1, touchPos2) => {
+            var _a;
+            if (!this.sceneRoot)
+                return;
+            const transformNode = this.sceneRoot.transform;
+            const currentTouchDist = this.getTouchDistance(touchPos1, touchPos2);
+            const touchDelta = currentTouchDist - this.previousDistanceBetweenTouches;
+            const currentScale = this.sceneRoot.scale;
+            const scaleDelta = touchDelta * this.sensitivity * currentScale;
+            let newScale = currentScale + scaleDelta;
+            if (newScale < this.sceneRoot.minScale) {
+                newScale = this.sceneRoot.minScale;
+            }
+            else if (newScale > this.sceneRoot.maxScale) {
+                newScale = this.sceneRoot.maxScale;
+            }
+            transformNode.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
+            const touchCenter = this.getTouchCenter(touchPos1, touchPos2);
+            const pickRay = Babylon_1.pixelToSceneRay(touchCenter, this.appObjects);
+            const planePick = (_a = this.panPlane.intersectLine(pickRay)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            const globalOffset = transformNode.localPointToWorld(this.pickOffset);
+            const delta = ValueObjects_1.Vector3.Subtract(planePick, globalOffset);
+            const currentWorldPos = transformNode.worldPosition;
+            const newWorldPos = ValueObjects_1.Vector3.Add(currentWorldPos, delta);
+            transformNode.worldPosition = newWorldPos;
+            this.previousDistanceBetweenTouches = currentTouchDist;
+        };
+        this.finishPinch = () => {
+            var _a;
+            if (this.initialScale === ((_a = this.sceneRoot) === null || _a === void 0 ? void 0 : _a.scale))
+                return;
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.sceneRoot = appObject.getComponent(SceneRootEntity_1.SceneRootEntity.type);
+        if (!this.sceneRoot) {
+            this.warn("PinchSceneRootUC UC has been added to an App Object that does not have a SceneRoot Entity");
+            return;
+        }
+    }
+    getTouchCenter(t1, t2) {
+        const delta = ValueObjects_1.Vector2.Subtract(t2, t1);
+        const halfDelta = ValueObjects_1.Vector2.NewVectorOfLength(delta.unit, 0.5 * delta.magnitued);
+        return ValueObjects_1.Vector2.Add(t1, halfDelta);
+    }
+    getTouchDistance(t1, t2) {
+        const delta = ValueObjects_1.Vector2.Subtract(t2, t1);
+        return delta.magnitued;
+    }
+}

package/lib/Components/SceneRoot/UC/ScaleSceneRootWithRay.d.ts

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { ParametricLine, Vector3 } from "../../../ValueObjects";
+export declare class ScaleSceneRootWithRay extends AppObjectUC {
+    static readonly type = "ScaleSceneRootWithRay";
+    readonly sensitivity = 10;
+    private sceneRoot?;
+    private pickPoint;
+    private lastDistance;
+    doScale: (pickRay: ParametricLine, rayStart: Vector3) => void;
+    initializeScale: (pickRay: ParametricLine, rayStart: Vector3) => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/SceneRoot/UC/ScaleSceneRootWithRay.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScaleSceneRootWithRay = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const SceneRootEntity_1 = require("../Entities/SceneRootEntity");
+class ScaleSceneRootWithRay extends AppObjectUC_1.AppObjectUC {
+    constructor(appObject) {
+        super(appObject, ScaleSceneRootWithRay.type);
+        this.sensitivity = 10;
+        this.pickPoint = ValueObjects_1.Vector3.Zero();
+        this.lastDistance = 0;
+        this.doScale = (pickRay, rayStart) => {
+            if (!this.sceneRoot)
+                return;
+            const newDistance = ValueObjects_1.Vector3.Subtract(rayStart, this.pickPoint).magnitude;
+            const distanceChange = newDistance - this.lastDistance;
+            const currentScale = this.sceneRoot.scale;
+            const scaleDelta = distanceChange * this.sensitivity * currentScale;
+            this.sceneRoot.bumpScaleAboutPoint(scaleDelta, this.pickPoint);
+            this.lastDistance = newDistance;
+        };
+        this.initializeScale = (pickRay, rayStart) => {
+            var _a;
+            const pick = Babylon_1.sceneRayPick(pickRay, this.appObjects);
+            this.pickPoint = (_a = pick === null || pick === void 0 ? void 0 : pick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this.lastDistance = ValueObjects_1.Vector3.Subtract(rayStart, this.pickPoint).magnitude;
+        };
+        this.sceneRoot = appObject.getComponent(SceneRootEntity_1.SceneRootEntity.type);
+        if (!this.sceneRoot) {
+            this.warn("ScaleSceneRootWithRay added to an app object that does not have a SceneRootEntity");
+        }
+    }
+}
+exports.ScaleSceneRootWithRay = ScaleSceneRootWithRay;
+ScaleSceneRootWithRay.type = "ScaleSceneRootWithRay";

package/lib/Components/SceneRoot/UC/SerializeSceneRoot.d.ts

@@ -0,0 +1,31 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { SerializedSystem } from "../../StateMachine/Entities/StateMachineEntity";
+export declare abstract class SerializeSceneRoot extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeSceneRoot";
+    name: string;
+    abstract seriliziationVersion: number;
+    abstract getSystemState(): object;
+    abstract applySystemState(state: object, version: number, transitionDuration: number): void;
+    abstract applyDefaultState(transitionDuration: number): void;
+}
+export declare function makeSerializeSceneRoot(appObject: AppObject): SerializeSceneRoot;
+export interface SceneRootDataV1 {
+    position: [number, number, number];
+    rotation: [number, number, number, number];
+    scale: [number, number, number];
+}
+export interface SceneRootDataV2 {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: number;
+}

package/lib/Components/SceneRoot/UC/SerializeSceneRoot.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSerializeSceneRoot = exports.SerializeSceneRoot = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const StateMachineEntity_1 = require("../../StateMachine/Entities/StateMachineEntity");
+const StoredView_1 = require("../../StoredView");
+const SceneRootEntity_1 = require("../Entities/SceneRootEntity");
+class SerializeSceneRoot extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.name = "sceneRoot";
+    }
+}
+exports.SerializeSceneRoot = SerializeSceneRoot;
+SerializeSceneRoot.type = "SerializeSceneRoot";
+function makeSerializeSceneRoot(appObject) {
+    return new SerializeSceneRootImp(appObject);
+}
+exports.makeSerializeSceneRoot = makeSerializeSceneRoot;
+class SerializeSceneRootImp extends SerializeSceneRoot {
+    constructor(appObject) {
+        super(appObject, SerializeSceneRoot.type);
+        this.seriliziationVersion = 2;
+        this.sceneRoot = appObject.getComponent(SceneRootEntity_1.SceneRootEntity.type);
+        if (!this.sceneRoot) {
+            this.warn("SerializeSceneRoot UC has been added to an App Object that does not have a SceneRoot Entity. Add one before adding the UC");
+            this.dispose();
+            return;
+        }
+        this.storedView = appObject.getComponent(StoredView_1.StoredView.type);
+        if (!this.storedView) {
+            this.warn("SerializeSceneRoot UC has been added to an App Object that does not have a StoredView Entity. Stored view won't work until one is added to the UC");
+            return;
+        }
+        this.stateMachine = StateMachineEntity_1.StateMachineEntity.get(appObject.appObjectRepo);
+        if (this.stateMachine) {
+            this.stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            this.warn("Unable to find StateMachineEntity");
+        }
+    }
+    getSystemState() {
+        if (!this.sceneRoot) {
+            this.warn("No scene root entity");
+            return {};
+        }
+        if (this.storedView && this.storedView.hasStoredView) {
+            const data = {
+                position: this.storedView.position.dto,
+                rotation: this.storedView.rotation.dto,
+                scale: this.storedView.scale,
+            };
+            return data;
+        }
+        else {
+            const data = {
+                position: this.sceneRoot.position.dto,
+                rotation: this.sceneRoot.rotation.dto,
+                scale: this.sceneRoot.scale,
+            };
+            return data;
+        }
+    }
+    applySystemState(serializedState, version, transitionTime) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState, transitionTime);
+            }
+            else if (version === 2) {
+                const castState = serializedState;
+                this.applyV2Data(castState, transitionTime);
+            }
+            else {
+                console.warn(`Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState(transitionTime);
+            }
+        }
+        catch (e) {
+            this.warn(`Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState(transitionTime);
+        }
+    }
+    applyDefaultState(transitionDuration) {
+        if (!this.sceneRoot || !this.stateMachine) {
+            return;
+        }
+        this.sceneRoot.lerpToDefault(transitionDuration * 1000, this.stateMachine.transitionEaseFunction);
+    }
+    applyV2Data(data, transitionTime) {
+        if (!this.sceneRoot || !this.stateMachine) {
+            return;
+        }
+        const pos = ValueObjects_1.Vector3.FromDTO(data.position);
+        const rot = ValueObjects_1.Quaternion.FromDTO(data.rotation);
+        const scale = new ValueObjects_1.Vector3(data.scale, data.scale, data.scale);
+        const rootTransform = this.sceneRoot.transform;
+        const lerpDTO = {
+            durationMS: transitionTime * 1000,
+            ease: this.stateMachine.transitionEaseFunction,
+            desiredPosition: pos,
+            desiredRotation: rot,
+            desiredScale: scale,
+        };
+        rootTransform.lerp(lerpDTO);
+    }
+    applyV1Data(data, transitionTime) {
+        if (!this.sceneRoot || !this.stateMachine) {
+            return;
+        }
+        const pos = ValueObjects_1.Vector3.FromArray(data.position);
+        const rot = ValueObjects_1.Quaternion.FromArray(data.rotation);
+        const scale = ValueObjects_1.Vector3.FromArray(data.scale);
+        const rootTransform = this.sceneRoot.transform;
+        const lerpDTO = {
+            durationMS: transitionTime * 1000,
+            ease: this.stateMachine.transitionEaseFunction,
+            desiredPosition: pos,
+            desiredRotation: rot,
+            desiredScale: scale,
+        };
+        rootTransform.lerp(lerpDTO);
+    }
+}

package/lib/Components/SceneRoot/UC/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./BumpSceneRootScaleAboutPixelPoint";
+export * from "./CenterSceneRootOnPixelPick";
+export * from "./DragScaleSceneRoot";
+export * from "./FocusOnPixel";
+export * from "./OrbitSceneRoot";
+export * from "./PanSceneRoot";
+export * from "./PinchSceneRoot";
+export * from "./ScaleSceneRootWithRay";
+export * from "./SerializeSceneRoot";

package/lib/Components/SceneRoot/UC/index.js

@@ -0,0 +1,21 @@
+"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("./BumpSceneRootScaleAboutPixelPoint"), exports);
+__exportStar(require("./CenterSceneRootOnPixelPick"), exports);
+__exportStar(require("./DragScaleSceneRoot"), exports);
+__exportStar(require("./FocusOnPixel"), exports);
+__exportStar(require("./OrbitSceneRoot"), exports);
+__exportStar(require("./PanSceneRoot"), exports);
+__exportStar(require("./PinchSceneRoot"), exports);
+__exportStar(require("./ScaleSceneRootWithRay"), exports);
+__exportStar(require("./SerializeSceneRoot"), exports);

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

@@ -0,0 +1,3 @@
+export * from "./Entities";
+export * from "./UC";
+export * from "./Controllers";

package/lib/Components/SceneRoot/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("./Entities"), exports);
+__exportStar(require("./UC"), exports);
+__exportStar(require("./Controllers"), exports);

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

@@ -0,0 +1,30 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+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 declare abstract class StateMachineEntity extends AppObjectEntity {
+    static readonly type = "StateMachineEntity";
+    abstract transitionEaseFunction: (normalizedTime: number) => number;
+    abstract getSerializedStates(): SerializedStates;
+    abstract setSerializedStates(state: SerializedStates, transitionTime: number): void;
+    abstract applySerializedStatesString: (state: string, duration?: number) => void;
+    abstract setDefaultState(transitionTime: number): void;
+    abstract registerSerializedSystem(serializedSystem: SerializedSystem): void;
+    static get: (appObjects: AppObjectRepo) => StateMachineEntity | undefined;
+}
+export declare function makeStateMachineEntity(appObject: AppObject): StateMachineEntity;

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStateMachineEntity = exports.StateMachineEntity = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+class StateMachineEntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.StateMachineEntity = StateMachineEntity;
+StateMachineEntity.type = "StateMachineEntity";
+StateMachineEntity.get = (appObjects) => AppObject_1.getSingletonComponent(StateMachineEntity.type, appObjects);
+function makeStateMachineEntity(appObject) {
+    return new StateMachineImp(appObject);
+}
+exports.makeStateMachineEntity = makeStateMachineEntity;
+class StateMachineImp extends StateMachineEntity {
+    constructor(appObject) {
+        super(appObject, StateMachineEntity.type);
+        this.serializedSystems = new Map();
+        this.serilizationVersion = 2;
+        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);
+                    this.warn(`Failed to deserialize state string ${state} with Error ${e.message}`);
+                }
+            }
+        };
+        this.registerSerializedSystem = (serializedSystem) => {
+            if (this.serializedSystems.has(serializedSystem.name)) {
+                this.warn(`Duplicate stateable systems encountered: ${serializedSystem.name}`);
+                return;
+            }
+            this.serializedSystems.set(serializedSystem.name, serializedSystem);
+            return;
+        };
+        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 = (states, duration) => {
+            if (states.version === 2) {
+                const appliedToSystems = [];
+                states.systems.forEach((systemState) => {
+                    const seriliazableSystem = this.serializedSystems.get(systemState.name);
+                    if (seriliazableSystem) {
+                        seriliazableSystem.applySystemState(systemState.state, systemState.seriliziationVersion, duration);
+                    }
+                    else {
+                        this.warn(`Unable to find serializedSystem ${systemState.name}`);
+                    }
+                    appliedToSystems.push(systemState.name);
+                });
+                this.serializedSystems.forEach((system) => {
+                    if (!appliedToSystems.includes(system.name)) {
+                        system.applyDefaultState(duration);
+                    }
+                });
+                this.notifyOnChange();
+                return;
+            }
+            // Here is where we will add support for future versions
+            else {
+                this.warn(`Unsupported serialized state encountered: ${states.version}`);
+                return;
+            }
+        };
+        this.setDefaultState = (duration) => {
+            this.serializedSystems.forEach((system) => {
+                system.applyDefaultState(duration);
+            });
+            this.notifyOnChange();
+        };
+    }
+}

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./StateMachineEntity"), exports);

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

@@ -0,0 +1,12 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { StateMachineEntity } from "../Entities";
+export declare class MockStateMachine extends StateMachineEntity {
+    transitionEaseFunction: jest.Mock<any, any>;
+    getSerializedStates: jest.Mock<any, any>;
+    setSerializedStates: jest.Mock<any, any>;
+    applySerializedStatesString: jest.Mock<any, any>;
+    setDefaultState: jest.Mock<any, any>;
+    registerSerializedSystem: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockStateMachine = void 0;
+const Entities_1 = require("../Entities");
+class MockStateMachine extends Entities_1.StateMachineEntity {
+    constructor(appObject) {
+        super(appObject, Entities_1.StateMachineEntity.type);
+        this.transitionEaseFunction = jest.fn();
+        this.getSerializedStates = jest.fn();
+        this.setSerializedStates = jest.fn();
+        this.applySerializedStatesString = jest.fn();
+        this.setDefaultState = jest.fn();
+        this.registerSerializedSystem = jest.fn();
+    }
+}
+exports.MockStateMachine = MockStateMachine;

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MockStateMachine"), exports);

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

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

package/lib/Components/StateMachine/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Entities"), exports);

package/lib/Components/StoredView/Entities/StoredView.d.ts

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { Quaternion, Vector3 } from "../../../ValueObjects";
+export declare abstract class StoredView extends AppObjectEntity {
+    static readonly type = "STORED_VIEW";
+    abstract position: Vector3;
+    abstract rotation: Quaternion;
+    abstract scale: number;
+    abstract hasStoredView: boolean;
+    static get: (appObjects: AppObjectRepo) => StoredView | undefined;
+}
+export declare function makeStoredView(appObj: AppObject): StoredView;

package/lib/Components/StoredView/Entities/StoredView.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStoredView = exports.StoredView = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+class StoredView extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.StoredView = StoredView;
+StoredView.type = "STORED_VIEW";
+StoredView.get = (appObjects) => AppObject_1.getSingletonComponent(StoredView.type, appObjects);
+function makeStoredView(appObj) {
+    return new StoredViewImp(appObj);
+}
+exports.makeStoredView = makeStoredView;
+class StoredViewImp extends StoredView {
+    constructor(appObject) {
+        super(appObject, StoredView.type);
+        this._position = ValueObjects_1.Vector3.Zero();
+        this._rotation = ValueObjects_1.Quaternion.Identity();
+        this._memoizedScale = new Entities_1.MemoizedNumber(1, this.notifyOnChange);
+        this._memoizedHasStoredView = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+    }
+    get position() {
+        return this._position;
+    }
+    set position(p) {
+        if (ValueObjects_1.Vector3.Equal(this._position, p))
+            return;
+        this._position = p;
+        this.notifyOnChange();
+    }
+    get rotation() {
+        return this._rotation;
+    }
+    set rotation(r) {
+        if (ValueObjects_1.Quaternion.Equal(this._rotation, r))
+            return;
+        this._rotation = r;
+        this.notifyOnChange();
+    }
+    get scale() {
+        return this._memoizedScale.val;
+    }
+    set scale(s) {
+        this._memoizedScale.val = s;
+    }
+    get hasStoredView() {
+        return this._memoizedHasStoredView.val;
+    }
+    set hasStoredView(hasStoredValue) {
+        this._memoizedHasStoredView.val = hasStoredValue;
+    }
+}

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

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

package/lib/Components/StoredView/Entities/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./StoredView"), exports);