@vived/app 2.30.0 → 2.31.0

package/lib/Entities/AppDispatcher.d.ts

@@ -9,6 +9,10 @@ export declare abstract class AppDispatcher {
     abstract dispatch: (request: Request) => void;
     abstract stateHasChanged: (state: object, 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;
@@ -24,5 +28,6 @@ export declare abstract class AppDispatcher {
     abstract getAssetMeta: (assetID: string) => Promise<AssetMetaDTO>;
     abstract getAssetsForOwner: (ownerID: string) => Promise<AssetMetaDTO[]>;
     abstract submitNewActivityAsset: (file: File) => Promise<string>;
+    abstract stopZSpace: () => void;
 }
 export declare function makeAppDispatcher(): AppDispatcher;

package/lib/Entities/AppDispatcher.js

@@ -228,6 +228,47 @@ class AppDistpatcherImp extends AppDispatcher {
                 }
             });
         };
+        this.goToPreviousState = () => {
+            this.formRequestAndDispatch("GO_TO_PREVIOUS_STATE", 1);
+        };
+        this.goToNextState = () => {
+            this.formRequestAndDispatch("GO_TO_NEXT_STATE", 1);
+        };
+        this.stopZSpace = () => {
+            this.formRequestAndDispatch("STOP_ZSPACE", 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);
+                }
+            });
+        };
     }
     formRequestAndDispatch(type, version, payload) {
         const request = {

package/lib/Entities/Babylon.d.ts

@@ -1,4 +1,4 @@
-import { ParametricLine, Result, Vector2, Vector3 } from "../ValueObjects";
+import { ParametricLine, Vector2, Vector3 } from "../ValueObjects";
 export declare type OnBabylonChange = () => void;
 export interface ScenePick {
     mouseRay: ParametricLine;
@@ -6,17 +6,18 @@ export interface ScenePick {
     worldPickPoint?: Vector3;
     objectPickMeta?: object;
 }
-export declare type ScenePicker = (pixelPos: Vector2) => ScenePick;
-export declare type SceneRayer = (pixelPos: Vector2) => ParametricLine;
 export interface Babylon {
     engine: unknown;
     scene: unknown;
     workingCanvas?: HTMLCanvasElement;
     showInspector: boolean;
     renderCanvas?: HTMLCanvasElement;
-    scenePick: (pixelPos: Vector2) => ScenePick;
-    sceneRay: (pixelPos: Vector2) => ParametricLine;
-    sceneObjectPick: (pixelPos: Vector2) => Result<string, SceneObjectPickErrors>;
+    isRendering: boolean;
+    pixelToSceneRay: (pixelPos: Vector2) => ParametricLine;
+    sceneRayPick: (ray: ParametricLine) => ScenePick | undefined;
+    scenePixelPick: (pixelPos: Vector2) => ScenePick | undefined;
+    sceneObjectRayPick: (ray: ParametricLine) => string | undefined;
+    sceneObjectPixelPick: (pixelPos: Vector2) => string | undefined;
     makeSceneObjectMeta: (id: string) => object;
     updateCanvasSize: () => void;
     submitRenderCanvas: (canvas: HTMLCanvasElement) => void;
@@ -24,19 +25,7 @@ export interface Babylon {
     registerResizeEnging: (resizeEngine: () => void) => void;
     registerStartRendering: (startRendering: (canvas: HTMLCanvasElement) => void) => void;
     registerStopRendering: (stopRendering: (canvas: HTMLCanvasElement) => void) => void;
-    registerScenePicker: (picker: ScenePicker) => void;
-    registerSceneRayer: (rayer: SceneRayer) => void;
     addObserver: (observer: OnBabylonChange) => void;
     removeObserver: (observer: OnBabylonChange) => void;
 }
 export declare function makeBabylon(): Babylon;
-export declare class SceneObjectPickErrorNoPicker extends Error {
-    constructor();
-}
-export declare class SceneObjectPickErrorNoPick extends Error {
-    constructor();
-}
-export declare class SceneObjectPickErrorNoID extends Error {
-    constructor();
-}
-export declare type SceneObjectPickErrors = SceneObjectPickErrorNoPicker | SceneObjectPickErrorNoPick | SceneObjectPickErrorNoID;

package/lib/Entities/Babylon.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SceneObjectPickErrorNoID = exports.SceneObjectPickErrorNoPick = exports.SceneObjectPickErrorNoPicker = exports.makeBabylon = void 0;
+exports.makeBabylon = void 0;
 const ValueObjects_1 = require("../ValueObjects");
 const MemoizedBoolean_1 = require("./MemoizedBoolean");
 const MemoizedVector2_1 = require("./MemoizedVector2");
@@ -11,18 +11,6 @@ function makeBabylon() {
 exports.makeBabylon = makeBabylon;
 class BabylonImp {
     constructor() {
-        this._scenePickerHasBeenSet = false;
-        this.scenePick = () => {
-            console.warn("orignal scene picker");
-            return {
-                mouseRay: ValueObjects_1.ParametricLine.Forward(),
-                hit: false,
-            };
-        };
-        this.sceneRay = () => {
-            console.warn("orignal scene ray");
-            return ValueObjects_1.ParametricLine.Forward();
-        };
         this.observers = new ObserverList_1.ObserverList();
         this.updateCanvasSize = () => {
             if (!this.workingCanvas)
@@ -77,33 +65,56 @@ class BabylonImp {
         this.removeObserver = (observer) => {
             this.observers.remove(observer);
         };
-        this.registerScenePicker = (picker) => {
-            this.scenePick = picker;
-            this._scenePickerHasBeenSet = true;
+        this.makeSceneObjectMeta = (id) => {
+            return { sceneObjectID: id };
+        };
+        this.getSceneObjectIDFromMeta = (meta) => {
+            if (meta === null || meta === void 0 ? void 0 : meta.hasOwnProperty("sceneObjectID")) {
+                return meta.sceneObjectID;
+            }
+            else {
+                return;
+            }
         };
-        this.registerSceneRayer = (rayer) => {
-            this.sceneRay = rayer;
+        this.memoizedIsRendering = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
+        this.sceneRayPick = (ray) => {
+            throw new Error("Scene ray pick has not been injected");
         };
-        this.sceneObjectPick = (pixelPos) => {
-            var _a;
-            if (!this._scenePickerHasBeenSet) {
-                return ValueObjects_1.reject(new SceneObjectPickErrorNoPicker());
+        this.sceneObjectRayPick = (ray) => {
+            try {
+                const pick = this.sceneRayPick(ray);
+                if (pick === undefined)
+                    return;
+                const sceneObjectId = this.getSceneObjectIDFromMeta(pick.objectPickMeta);
+                return sceneObjectId;
             }
-            const scenePick = this.scenePick(pixelPos);
-            if (!scenePick.hit) {
-                return ValueObjects_1.reject(new SceneObjectPickErrorNoPick());
+            catch (e) {
+                console.warn(e);
+                return;
             }
-            if (!((_a = scenePick.objectPickMeta) === null || _a === void 0 ? void 0 : _a.hasOwnProperty("sceneObjectID"))) {
-                return ValueObjects_1.reject(new SceneObjectPickErrorNoID());
+        };
+        this.sceneObjectPixelPick = (pixelPos) => {
+            try {
+                const ray = this.pixelToSceneRay(pixelPos);
+                return this.sceneObjectRayPick(ray);
             }
-            const sceneObjectId = scenePick.objectPickMeta.sceneObjectID;
-            if (!sceneObjectId) {
-                return ValueObjects_1.reject(new SceneObjectPickErrorNoID());
+            catch (e) {
+                console.warn(e);
+                return;
             }
-            return ValueObjects_1.resolve(sceneObjectId);
         };
-        this.makeSceneObjectMeta = (id) => {
-            return { sceneObjectID: id };
+        this.scenePixelPick = (pixelPos) => {
+            try {
+                const ray = this.pixelToSceneRay(pixelPos);
+                return this.sceneRayPick(ray);
+            }
+            catch (e) {
+                console.warn(e);
+                return;
+            }
+        };
+        this.pixelToSceneRay = (pixelPos) => {
+            throw new Error("Pixel to scene ray has not been injected");
         };
         this.memoizedShowInspector = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
         this.memoizedCanvasSize = new MemoizedVector2_1.MemoizedVector2(ValueObjects_1.Vector2.One(), this.observers.notify);
@@ -123,25 +134,10 @@ class BabylonImp {
     set canvasSize(val) {
         this.memoizedCanvasSize.val = val;
     }
-}
-class SceneObjectPickErrorNoPicker extends Error {
-    constructor() {
-        super();
-        this.message = "No picker has been registered";
-    }
-}
-exports.SceneObjectPickErrorNoPicker = SceneObjectPickErrorNoPicker;
-class SceneObjectPickErrorNoPick extends Error {
-    constructor() {
-        super();
-        this.message = "Nothing was picked on";
+    get isRendering() {
+        return this.memoizedIsRendering.val;
     }
-}
-exports.SceneObjectPickErrorNoPick = SceneObjectPickErrorNoPick;
-class SceneObjectPickErrorNoID extends Error {
-    constructor() {
-        super();
-        this.message = "Picked object does not have a scene ID";
+    set isRendering(val) {
+        this.memoizedIsRendering.val = val;
     }
 }
-exports.SceneObjectPickErrorNoID = SceneObjectPickErrorNoID;

package/lib/Entities/BaseApp.d.ts

@@ -1,7 +1,9 @@
+import { ObservableEntity } from "./ObservableEntity";
 export declare type OnBaseAppChange = () => void;
-export interface BaseApp {
-    isAuthoring: boolean;
-    addObserver(observer: OnBaseAppChange): void;
-    removeObserver(observer: OnBaseAppChange): void;
+export declare abstract class BaseApp extends ObservableEntity {
+    abstract get isAuthoring(): boolean;
+    abstract set isAuthoring(val: boolean);
+    abstract startRendering: (container: HTMLElement) => void;
+    abstract stopRendering: () => void;
 }
 export declare function makeBaseApp(): BaseApp;

package/lib/Entities/BaseApp.js

@@ -1,22 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeBaseApp = void 0;
+exports.makeBaseApp = exports.BaseApp = void 0;
 const MemoizedBoolean_1 = require("./MemoizedBoolean");
-const ObserverList_1 = require("./ObserverList");
+const ObservableEntity_1 = require("./ObservableEntity");
+class BaseApp extends ObservableEntity_1.ObservableEntity {
+}
+exports.BaseApp = BaseApp;
 function makeBaseApp() {
     return new BaseAppImp();
 }
 exports.makeBaseApp = makeBaseApp;
-class BaseAppImp {
+class BaseAppImp extends BaseApp {
     constructor() {
-        this.observers = new ObserverList_1.ObserverList();
-        this.memoizedIsAuthoring = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
-        this.addObserver = (observer) => {
-            this.observers.add(observer);
+        super(...arguments);
+        this.startRendering = (container) => {
+            throw new Error("[Base App] Start rendering function has not been injected");
         };
-        this.removeObserver = (observer) => {
-            this.observers.remove(observer);
+        this.stopRendering = () => {
+            throw new Error("[Base App] Stop rendering function has not been injected");
         };
+        this.memoizedIsAuthoring = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
     }
     get isAuthoring() {
         return this.memoizedIsAuthoring.val;

package/lib/PresentationManagers/IsAuthoringPM.d.ts

@@ -1,9 +1,9 @@
 import { BaseApp } from "../Entities";
-export declare class IsAuthoringPM {
+import { PresentionManager } from "./PresentationManager";
+export declare class IsAuthoringPM extends PresentionManager {
     private baseApp;
     private updateView;
     private lastSetState?;
-    private doUpdateView;
-    dispose(): void;
+    doUpdateView: () => void;
     constructor(baseApp: BaseApp, updateView: (isAuthoring: boolean) => void);
 }

package/lib/PresentationManagers/IsAuthoringPM.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsAuthoringPM = void 0;
-class IsAuthoringPM {
+const PresentationManager_1 = require("./PresentationManager");
+class IsAuthoringPM extends PresentationManager_1.PresentionManager {
     constructor(baseApp, updateView) {
+        super(baseApp);
+        this.baseApp = baseApp;
+        this.updateView = updateView;
         this.doUpdateView = () => {
             const isAuthoring = this.baseApp.isAuthoring;
             if (isAuthoring === this.lastSetState)
@@ -10,13 +14,7 @@ class IsAuthoringPM {
             this.updateView(isAuthoring);
             this.lastSetState = isAuthoring;
         };
-        this.baseApp = baseApp;
-        this.updateView = updateView;
         this.doUpdateView();
-        this.baseApp.addObserver(this.doUpdateView);
-    }
-    dispose() {
-        this.baseApp.removeObserver(this.doUpdateView);
     }
 }
 exports.IsAuthoringPM = IsAuthoringPM;

package/lib/PresentationManagers/IsRenderingPM.d.ts

@@ -0,0 +1,9 @@
+import { BaseApp } from "../Entities";
+import { PresentionManager } from "./PresentationManager";
+export declare class IsRenderingPM extends PresentionManager {
+    private baseApp;
+    private updateView;
+    private lastSetState?;
+    doUpdateView: () => void;
+    constructor(baseApp: BaseApp, updateView: (isAuthoring: boolean) => void);
+}

package/lib/PresentationManagers/IsRenderingPM.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsRenderingPM = void 0;
+const PresentationManager_1 = require("./PresentationManager");
+class IsRenderingPM extends PresentationManager_1.PresentionManager {
+    constructor(baseApp, updateView) {
+        super(baseApp);
+        this.baseApp = baseApp;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const isRendering = this.baseApp.isRendering;
+            if (isRendering === this.lastSetState)
+                return;
+            this.updateView(isRendering);
+            this.lastSetState = isRendering;
+        };
+        this.doUpdateView();
+    }
+}
+exports.IsRenderingPM = IsRenderingPM;

package/lib/UseCases/Handlers/SetZSpaceEnabledBase.d.ts

@@ -0,0 +1,10 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare type SetZSpaceEnabledAction = (isEnabled: boolean) => void;
+export declare class SetZSpaceEnabledBase extends RequestHandler {
+    readonly requestType = "SET_ZSPACE_ENABLED";
+    readonly payloadVersion = 1;
+    action: SetZSpaceEnabledAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/SetZSpaceEnabledBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetZSpaceEnabledBase = void 0;
+const Entities_1 = require("../../Entities");
+class SetZSpaceEnabledBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "SET_ZSPACE_ENABLED";
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { isEnabled } = this.castPayloadV1(payload);
+                this.action(isEnabled);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.isEnabled === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.SetZSpaceEnabledBase = SetZSpaceEnabledBase;

package/lib/UseCases/Handlers/StartZSpaceBase.d.ts

@@ -0,0 +1,10 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare type StartZSpaceAction = (device: string, session: any) => void;
+export declare class StartZSpaceBase extends RequestHandler {
+    readonly requestType = "START_ZSPACE";
+    readonly payloadVersion = 1;
+    action: StartZSpaceAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/StartZSpaceBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartZSpaceBase = void 0;
+const Entities_1 = require("../../Entities");
+class StartZSpaceBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "START_ZSPACE";
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { device, session } = this.castPayloadV1(payload);
+                this.action(device, session);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.device === undefined || castPayload.session === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.StartZSpaceBase = StartZSpaceBase;

package/lib/UseCases/Handlers/StopZSpaceBase.d.ts

@@ -0,0 +1,8 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare class StopZSpaceBase extends RequestHandler {
+    readonly requestType = "STOP_ZSPACE";
+    readonly payloadVersion = 1;
+    action: () => void;
+    handleRequest: (version: number) => void;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/StopZSpaceBase.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopZSpaceBase = void 0;
+const Entities_1 = require("../../Entities");
+class StopZSpaceBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "STOP_ZSPACE";
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+}
+exports.StopZSpaceBase = StopZSpaceBase;

package/lib/UseCases/Handlers/index.d.ts

@@ -2,6 +2,8 @@ export * from "./DisposeAppBase";
 export * from "./SetAppStateBase";
 export * from "./SetDevicePreviewBase";
 export * from "./SetIsAuthoringBase";
+export * from "./StartZSpaceBase";
 export * from "./ShowBabylonInspectorBase";
 export * from "./StartAppBase";
 export * from "./StopAppBase";
+export * from "./StopZSpaceBase";

package/lib/UseCases/Handlers/index.js

@@ -14,6 +14,8 @@ __exportStar(require("./DisposeAppBase"), exports);
 __exportStar(require("./SetAppStateBase"), exports);
 __exportStar(require("./SetDevicePreviewBase"), exports);
 __exportStar(require("./SetIsAuthoringBase"), exports);
+__exportStar(require("./StartZSpaceBase"), exports);
 __exportStar(require("./ShowBabylonInspectorBase"), exports);
 __exportStar(require("./StartAppBase"), exports);
 __exportStar(require("./StopAppBase"), exports);
+__exportStar(require("./StopZSpaceBase"), exports);

package/lib/UseCases/HoverLabels/trySetHoverLabel.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeTrySetHoverLabel = void 0;
 function makeTrySetHoverLabel(hoverLabels, babylon) {
     return function trySetHoverLabel(position) {
-        babylon.sceneObjectPick(position).then(sceneObjectID => {
+        const sceneObjectID = babylon.sceneObjectPixelPick(position);
+        if (sceneObjectID) {
             hoverLabels.showLabelForSceneObject(sceneObjectID, position);
-        });
+        }
     };
 }
 exports.makeTrySetHoverLabel = makeTrySetHoverLabel;

package/package.json

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