@vived/app 3.4.0 → 3.5.1

package/lib/AppObjectComponents/Dispatcher/Factories/makeBasicDispatcher.js

@@ -3,11 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeBasicDispatcher = exports.APP_DISPATCHER_ID = void 0;
 const AppDispatcher_1 = require("../Entities/AppDispatcher");
 const DispatchStopZSpaceUC_1 = require("../UC/DispatchStopZSpaceUC");
+const GoToNextStateUC_1 = require("../UC/GoToNextStateUC");
+const GoToPreviousStateUC_1 = require("../UC/GoToPreviousStateUC");
+const HasNextStateUC_1 = require("../UC/HasNextStateUC");
+const HasPreviousStateUC_1 = require("../UC/HasPreviousStateUC");
 exports.APP_DISPATCHER_ID = "AppDispatcher";
 function makeBasicDispatcher(appObjects, hostHandler) {
     const dispatcherAO = appObjects.getOrCreate(exports.APP_DISPATCHER_ID);
     AppDispatcher_1.makeAppDispatcher(dispatcherAO, hostHandler);
     DispatchStopZSpaceUC_1.makeDispatchStopZSpaceUC(dispatcherAO);
+    GoToPreviousStateUC_1.makeGoToPreviousStateUC(dispatcherAO);
+    GoToNextStateUC_1.makeGoToNextStateUC(dispatcherAO);
+    HasPreviousStateUC_1.makeHasPreviousStateUC(dispatcherAO);
+    HasNextStateUC_1.makeHasNextStateUC(dispatcherAO);
     return dispatcherAO;
 }
 exports.makeBasicDispatcher = makeBasicDispatcher;

package/lib/AppObjectComponents/Dispatcher/UC/GoToNextStateUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class GoToNextStateUC extends AppObjectUC {
+    static readonly type = "GoToNextStateUC";
+    readonly requestType = "GO_TO_NEXT_STATE";
+    abstract doDispatch(): void;
+    static get(appObjects: AppObjectRepo): GoToNextStateUC | undefined;
+}
+export declare function makeGoToNextStateUC(appObject: AppObject): GoToNextStateUC;

package/lib/AppObjectComponents/Dispatcher/UC/GoToNextStateUC.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGoToNextStateUC = exports.GoToNextStateUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class GoToNextStateUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GO_TO_NEXT_STATE";
+    }
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(GoToNextStateUC.type);
+        if (selectionEntities.length === 0) {
+            console.warn("Unable to find a GoToNextStateUC. Add one on Mount");
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn("Multiple GoToNextStateUC have been found. There should only be one. Using the first one");
+        }
+        return selectionEntities[0];
+    }
+}
+exports.GoToNextStateUC = GoToNextStateUC;
+GoToNextStateUC.type = "GoToNextStateUC";
+function makeGoToNextStateUC(appObject) {
+    return new DispatchStateChangeUCImp(appObject);
+}
+exports.makeGoToNextStateUC = makeGoToNextStateUC;
+class DispatchStateChangeUCImp extends GoToNextStateUC {
+    constructor(appObject) {
+        super(appObject, GoToNextStateUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            console.warn("GoToNextStateUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        if (!this.appDispatcher)
+            return;
+        this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion);
+    }
+}

package/lib/AppObjectComponents/Dispatcher/UC/GoToPreviousStateUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class GoToPreviousStateUC extends AppObjectUC {
+    static readonly type = "GoToPreviousStateUC";
+    readonly requestType = "GO_TO_PREVIOUS_STATE";
+    abstract doDispatch(): void;
+    static get(appObjects: AppObjectRepo): GoToPreviousStateUC | undefined;
+}
+export declare function makeGoToPreviousStateUC(appObject: AppObject): GoToPreviousStateUC;

package/lib/AppObjectComponents/Dispatcher/UC/GoToPreviousStateUC.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGoToPreviousStateUC = exports.GoToPreviousStateUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class GoToPreviousStateUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GO_TO_PREVIOUS_STATE";
+    }
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(GoToPreviousStateUC.type);
+        if (selectionEntities.length === 0) {
+            console.warn("Unable to find a GoToPreviousStateUC. Add one on Mount");
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn("Multiple GoToPreviousStateUC have been found. There should only be one. Using the first one");
+        }
+        return selectionEntities[0];
+    }
+}
+exports.GoToPreviousStateUC = GoToPreviousStateUC;
+GoToPreviousStateUC.type = "GoToPreviousStateUC";
+function makeGoToPreviousStateUC(appObject) {
+    return new DispatchStateChangeUCImp(appObject);
+}
+exports.makeGoToPreviousStateUC = makeGoToPreviousStateUC;
+class DispatchStateChangeUCImp extends GoToPreviousStateUC {
+    constructor(appObject) {
+        super(appObject, GoToPreviousStateUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            console.warn("GoToPreviousStateUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        if (!this.appDispatcher)
+            return;
+        this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion);
+    }
+}

package/lib/AppObjectComponents/Dispatcher/UC/HasNextStateUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class HasNextStateUC extends AppObjectUC {
+    static readonly type = "HasNextStateUC";
+    readonly requestType = "HAS_NEXT_STATE";
+    abstract doDispatch(): Promise<boolean>;
+    static get(appObjects: AppObjectRepo): HasNextStateUC | undefined;
+}
+export declare function makeHasNextStateUC(appObject: AppObject): HasNextStateUC;

package/lib/AppObjectComponents/Dispatcher/UC/HasNextStateUC.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHasNextStateUC = exports.HasNextStateUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class HasNextStateUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "HAS_NEXT_STATE";
+    }
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(HasNextStateUC.type);
+        if (selectionEntities.length === 0) {
+            console.warn("Unable to find a HasNextStateUC. Add one on Mount");
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn("Multiple HasNextStateUC have been found. There should only be one. Using the first one");
+        }
+        return selectionEntities[0];
+    }
+}
+exports.HasNextStateUC = HasNextStateUC;
+HasNextStateUC.type = "HasNextStateUC";
+function makeHasNextStateUC(appObject) {
+    return new DispatchStateChangeUCImp(appObject);
+}
+exports.makeHasNextStateUC = makeHasNextStateUC;
+class DispatchStateChangeUCImp extends HasNextStateUC {
+    constructor(appObject) {
+        super(appObject, HasNextStateUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            console.warn("HasNextStateUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        return new Promise((resolve, reject) => {
+            const callback = (hasNextState) => {
+                resolve(hasNextState);
+            };
+            const payload = {
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}

package/lib/AppObjectComponents/Dispatcher/UC/HasPreviousStateUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class HasPreviousStateUC extends AppObjectUC {
+    static readonly type = "HasPreviousStateUC";
+    readonly requestType = "HAS_PREVIOUS_STATE";
+    abstract doDispatch(): Promise<boolean>;
+    static get(appObjects: AppObjectRepo): HasPreviousStateUC | undefined;
+}
+export declare function makeHasPreviousStateUC(appObject: AppObject): HasPreviousStateUC;

package/lib/AppObjectComponents/Dispatcher/UC/HasPreviousStateUC.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHasPreviousStateUC = exports.HasPreviousStateUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class HasPreviousStateUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "HAS_PREVIOUS_STATE";
+    }
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(HasPreviousStateUC.type);
+        if (selectionEntities.length === 0) {
+            console.warn("Unable to find a HasPreviousStateUC. Add one on Mount");
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn("Multiple HasPreviousStateUC have been found. There should only be one. Using the first one");
+        }
+        return selectionEntities[0];
+    }
+}
+exports.HasPreviousStateUC = HasPreviousStateUC;
+HasPreviousStateUC.type = "HasPreviousStateUC";
+function makeHasPreviousStateUC(appObject) {
+    return new DispatchStateChangeUCImp(appObject);
+}
+exports.makeHasPreviousStateUC = makeHasPreviousStateUC;
+class DispatchStateChangeUCImp extends HasPreviousStateUC {
+    constructor(appObject) {
+        super(appObject, HasPreviousStateUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            console.warn("HasPreviousStateUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        return new Promise((resolve, reject) => {
+            const callback = (hasNextState) => {
+                resolve(hasNextState);
+            };
+            const payload = {
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}

package/lib/AppObjectComponents/Dispatcher/index.d.ts

@@ -1,3 +1,7 @@
 export * from "./Entities/AppDispatcher";
 export * from "./Factories/makeBasicDispatcher";
 export * from "./UC/DispatchStopZSpaceUC";
+export * from "./UC/GoToNextStateUC";
+export * from "./UC/GoToPreviousStateUC";
+export * from "./UC/HasNextStateUC";
+export * from "./UC/HasPreviousStateUC";

package/lib/AppObjectComponents/Dispatcher/index.js

@@ -13,3 +13,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Entities/AppDispatcher"), exports);
 __exportStar(require("./Factories/makeBasicDispatcher"), exports);
 __exportStar(require("./UC/DispatchStopZSpaceUC"), exports);
+__exportStar(require("./UC/GoToNextStateUC"), exports);
+__exportStar(require("./UC/GoToPreviousStateUC"), exports);
+__exportStar(require("./UC/HasNextStateUC"), exports);
+__exportStar(require("./UC/HasPreviousStateUC"), exports);

package/lib/AppObjectComponents/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/AppObjectComponents/StoredView/Entities/StoredView.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStoredView = exports.StoredView = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+class StoredView extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        const repo = appObjects.getAllComponents(StoredView.type);
+        if (repo.length === 0) {
+            console.warn("[StoredView] Unable to find Scene Root Entity. Add one on Mount");
+            return undefined;
+        }
+        else if (repo.length > 1) {
+            console.warn("[StoredView] Multiple Scene Root Entity have been found. There should only be one. Using the first one");
+        }
+        return repo[0];
+    }
+}
+exports.StoredView = StoredView;
+StoredView.type = "STORED_VIEW";
+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/AppObjectComponents/StoredView/UC/SerializeStoredView.d.ts

@@ -0,0 +1,27 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { SerializedSystem, StateMachine } from "../../../Entities";
+export declare abstract class SerializeStoredView extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeStoredView";
+    name: string;
+    abstract seriliziationVersion: number;
+    abstract getSystemState(): object;
+    abstract applySystemState(state: object, version: number): void;
+    abstract applyDefaultState(transitionDuration: number): void;
+}
+export declare function makeSerializeStoredView(appObject: AppObject, stateMachine: StateMachine): SerializeStoredView;
+export interface StoredViewDataV1 {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: number;
+    hasStoredView: boolean;
+}

package/lib/AppObjectComponents/StoredView/UC/SerializeStoredView.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSerializeStoredView = exports.SerializeStoredView = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const StoredView_1 = require("../Entities/StoredView");
+class SerializeStoredView extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.name = "storedView";
+    }
+}
+exports.SerializeStoredView = SerializeStoredView;
+SerializeStoredView.type = "SerializeStoredView";
+function makeSerializeStoredView(appObject, stateMachine) {
+    return new SerializeStoredViewImp(appObject, stateMachine);
+}
+exports.makeSerializeStoredView = makeSerializeStoredView;
+class SerializeStoredViewImp extends SerializeStoredView {
+    constructor(appObject, stateMachine) {
+        super(appObject, SerializeStoredView.type);
+        this.seriliziationVersion = 1;
+        this.storedView = appObject.getComponent(StoredView_1.StoredView.type);
+        if (!this.storedView) {
+            console.warn("SerializeStoredView UC has been added to an App Object that does not have a StoredView Entity. Add one before adding the UC");
+            this.dispose();
+            return;
+        }
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        if (!this.storedView) {
+            console.warn("[SerializeStoredView] No stored view entity");
+            return {};
+        }
+        const data = {
+            position: this.storedView.position.dto,
+            rotation: this.storedView.rotation.dto,
+            scale: this.storedView.scale,
+            hasStoredView: this.storedView.hasStoredView,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState);
+            }
+            else {
+                console.warn(`[SerializeStoredView] Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState();
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializeStoredView] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState();
+        }
+    }
+    applyDefaultState() {
+        if (!this.storedView) {
+            console.warn("[SerializeStoredView] No stored view entity");
+            return;
+        }
+        this.storedView.position = ValueObjects_1.Vector3.Zero();
+        this.storedView.rotation = ValueObjects_1.Quaternion.Identity();
+        this.storedView.scale = 1;
+        this.storedView.hasStoredView = false;
+    }
+    applyV1Data(data) {
+        if (!this.storedView) {
+            console.warn("[SerializeStoredView] No stored view entity");
+            return;
+        }
+        const pos = ValueObjects_1.Vector3.FromDTO(data.position);
+        const rot = ValueObjects_1.Quaternion.FromDTO(data.rotation);
+        this.storedView.position = pos;
+        this.storedView.rotation = rot;
+        this.storedView.scale = data.scale;
+        this.storedView.hasStoredView = data.hasStoredView;
+    }
+}

package/lib/AppObjectComponents/StoredView/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Entities/StoredView";
+export * from "./UC/SerializeStoredView";

package/lib/AppObjectComponents/StoredView/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("./Entities/StoredView"), exports);
+__exportStar(require("./UC/SerializeStoredView"), exports);

package/lib/AppObjectComponents/Transform3D/UseCases/StickTransform3D.js

@@ -25,7 +25,15 @@ class StickTransform3D extends AppObjectUC_1.AppObjectUC {
     get canBeStuck() {
         if (!this.transform)
             return false;
-        return !ValueObjects_1.Vector3.Equal(this.transform.localPosition, ValueObjects_1.Vector3.Zero());
+        if (!ValueObjects_1.Vector3.Equal(this.transform.localPosition, ValueObjects_1.Vector3.Zero())) {
+            return true;
+        }
+        else if (!ValueObjects_1.Quaternion.Equal(this.transform.localRotation, ValueObjects_1.Quaternion.Identity())) {
+            return true;
+        }
+        else {
+            return false;
+        }
     }
     stick(onCompleteCallback) {
         var _a;
@@ -35,7 +43,7 @@ class StickTransform3D extends AppObjectUC_1.AppObjectUC {
             }
             return;
         }
-        (_a = this.transform) === null || _a === void 0 ? void 0 : _a.lerp(this.stickDurationMS, this.easeFn, ValueObjects_1.Vector3.Zero(), undefined, undefined, onCompleteCallback);
+        (_a = this.transform) === null || _a === void 0 ? void 0 : _a.lerp(this.stickDurationMS, this.easeFn, ValueObjects_1.Vector3.Zero(), ValueObjects_1.Quaternion.Identity(), undefined, onCompleteCallback);
     }
     static get(appObj) {
         return appObj.getComponent(this.type);

package/lib/Entities/AppDispatcher.d.ts

@@ -36,10 +36,6 @@ export declare abstract class AppDispatcher {
     abstract dispatch: (request: Request) => void;
     abstract stateHasChanged: (state: object, assets: string[], validationErrorMessage?: string) => void;
     abstract stateIsCompleted: () => void;
-    abstract goToPreviousState: () => void;
-    abstract goToNextState: () => void;
-    abstract hasPreviousState: () => Promise<boolean>;
-    abstract hasNextState: () => Promise<boolean>;
     abstract getAppAssetsURL: () => Promise<string>;
     abstract registerExternalStylesheets: (stylesheets: string[]) => void;
     abstract appIsReady: () => void;

package/lib/Entities/AppDispatcher.js

@@ -262,44 +262,6 @@ class AppDistpatcherImp extends AppDispatcher {
                 }
             });
         };
-        this.goToPreviousState = () => {
-            this.formRequestAndDispatch("GO_TO_PREVIOUS_STATE", 1);
-        };
-        this.goToNextState = () => {
-            this.formRequestAndDispatch("GO_TO_NEXT_STATE", 1);
-        };
-        this.hasNextState = () => {
-            return new Promise((resolve, reject) => {
-                const callback = (hasNextState) => {
-                    resolve(hasNextState);
-                };
-                const payload = {
-                    callback,
-                };
-                if (!this.hostHandler) {
-                    reject(new Error("No host handler has been registered"));
-                }
-                else {
-                    this.formRequestAndDispatch("HAS_NEXT_STATE", 1, payload);
-                }
-            });
-        };
-        this.hasPreviousState = () => {
-            return new Promise((resolve, reject) => {
-                const callback = (hasPreviousState) => {
-                    resolve(hasPreviousState);
-                };
-                const payload = {
-                    callback,
-                };
-                if (!this.hostHandler) {
-                    reject(new Error("No host handler has been registered"));
-                }
-                else {
-                    this.formRequestAndDispatch("HAS_PREVIOUS_STATE", 1, payload);
-                }
-            });
-        };
         this.showAlert = (data) => {
             const payload = {
                 title: data.title,

package/lib/Entities/FocusCamera.d.ts

@@ -0,0 +1,70 @@
+import { Vector3 } from "../ValueObjects";
+export declare type OnFocusCameraChange = () => void;
+export interface FocusCameraLerper {
+    cancelLerp: () => void;
+}
+export interface FocusCameraData {
+    defaultAlpha?: number;
+    defaultBeta?: number;
+    defaultRadius?: number;
+    defaultTarget?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    nearClip?: number;
+    farClip?: number;
+    alphaLimit?: {
+        min: number;
+        max: number;
+    };
+    betaLimit?: {
+        min: number;
+        max: number;
+    };
+    radiusLimit?: {
+        min: number;
+        max: number;
+    };
+    targetLimit?: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+}
+export interface FocusCamera {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target: Vector3;
+    direction: Vector3;
+    cameraPosition: Vector3;
+    nearClip: number;
+    farClip: number;
+    defaultAlpha: number;
+    defaultBeta: number;
+    defaultRadius: number;
+    defaultTarget: Vector3;
+    setAlphaLimits: (min: number, max: number) => void;
+    clearAlphaLimits: () => void;
+    setBetaLimits: (min: number, max: number) => void;
+    clearBetaLimits: () => void;
+    setRadiusLimits: (min: number, max: number) => void;
+    clearRadiusLimits: () => void;
+    setTargetLimits: (min: Vector3, max: Vector3) => void;
+    clearTargetLimits: () => void;
+    registerLerp: (lerper: FocusCameraLerper) => void;
+    lerpCompleted: () => void;
+    cancelLerp: () => void;
+    applyData: (data: FocusCameraData) => void;
+    addObserver: (observer: OnFocusCameraChange) => void;
+    removeObserver: (observer: OnFocusCameraChange) => void;
+}
+export declare function makeFocusCamera(): FocusCamera;