@vived/app 3.4.0 → 3.5.0

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/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/package.json

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