@vived/app 2.15.4 → 2.15.7

package/lib/Entities/DevicePreview.js

@@ -13,12 +13,17 @@ class DevicePreviewImp {
         this._usePreview = false;
         this._previewSize = ValueObjects_1.Vector2.Zero();
         this.setDevicePreview = (x, y) => {
-            if (this._usePreview &&
-                this._previewSize.x === x &&
+            if (this._previewSize.x === x &&
                 this._previewSize.y === y)
                 return;
             this._usePreview = true;
             this._previewSize = new ValueObjects_1.Vector2(x, y);
+            if (x > 0 && y > 0) {
+                this._usePreview = true;
+            }
+            else {
+                this._usePreview = false;
+            }
             this.observers.notify();
         };
         this.clearDevicePreview = () => {

package/lib/Entities/FocusCamera.js

@@ -33,14 +33,18 @@ class FocusCameraImp {
         this.memoizedRadius = new _1.MemoizedNumber(1, this.observers.notify);
         this.memoizedTarget = new _1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.observers.notify);
         this.setRadiusLimits = (min, max) => {
+            let minToUse = min;
+            let maxToUse = max;
             if (min < 0) {
-                throw new Error("[Orbit Camera] Mininum Radius must be greater >= 0");
+                console.warn("[Orbit Camera Entity] Mininum Radius must be greater >= 0, forcing to 0");
+                minToUse = 0;
             }
-            if (max < min) {
-                throw new Error("[Orbit Camera] Max radius must be >= min radius");
+            if (max < minToUse) {
+                console.warn(`[Orbit Camera] Max radius must be >= min radius. Forcing to ${minToUse}`);
+                maxToUse = minToUse;
             }
-            this.maxRadius = max;
-            this.minRadius = min;
+            this.maxRadius = maxToUse;
+            this.minRadius = minToUse;
             this.limitRadius = true;
             this.radius = this.radius;
         };
@@ -50,17 +54,26 @@ class FocusCameraImp {
             this.limitRadius = false;
         };
         this.setAlphaLimits = (min, max) => {
-            if (min > max) {
-                throw new Error("[Orbit Camera] Max alpha must be >= min alpha");
-            }
+            let minToUse = min;
+            let maxToUse = max;
             if (min < -180) {
-                throw new Error("[Orbit Camera] Min alpha must be >= -180");
+                minToUse = -180;
+                console.warn("[Orbit Camera] Min alpha must be >= -180. Forcing to -180");
             }
             if (max > 180) {
-                throw new Error("[Orbit Camera] Max alpha must be <= 180");
+                maxToUse = 180;
+                console.warn("[Orbit Camera] Max alpha must be <= 180. Forcing to 180");
+            }
+            if (minToUse > maxToUse) {
+                const absMin = Math.abs(minToUse);
+                const absMax = Math.abs(maxToUse);
+                const closestToZero = absMin < absMax ? minToUse : maxToUse;
+                minToUse = closestToZero;
+                maxToUse = closestToZero;
+                console.warn(`[Orbit Camera] Max alpha must be <= Min Alpha. Forcing to ${closestToZero}`);
             }
-            this.maxAlpha = max;
-            this.minAlpha = min;
+            this.maxAlpha = maxToUse;
+            this.minAlpha = minToUse;
             this.limitAlpha = true;
             this.alpha = this.alpha;
         };
@@ -70,17 +83,26 @@ class FocusCameraImp {
             this.limitAlpha = false;
         };
         this.setBetaLimits = (min, max) => {
-            if (min > max) {
-                throw new Error("[Orbit Camera] Max beta must be >= min beta");
-            }
+            let minToUse = min;
+            let maxToUse = max;
             if (min < -180) {
-                throw new Error("[Orbit Camera] Min beta must be >= -180");
+                minToUse = -180;
+                console.warn("[Orbit Camera] Min beta must be >= -180. Forcing to -180");
             }
             if (max > 180) {
-                throw new Error("[Orbit Camera] Max beta must be <= 180");
+                maxToUse = 180;
+                console.warn("[Orbit Camera] Max beta must be <= 180. Forcing to 180");
             }
-            this.maxBeta = max;
-            this.minBeta = min;
+            if (minToUse > maxToUse) {
+                const absMin = Math.abs(minToUse);
+                const absMax = Math.abs(maxToUse);
+                const closestToZero = absMin < absMax ? minToUse : maxToUse;
+                minToUse = closestToZero;
+                maxToUse = closestToZero;
+                console.warn(`[Orbit Camera] Max beta must be <= Min beta. Forcing to ${closestToZero}`);
+            }
+            this.maxBeta = maxToUse;
+            this.minBeta = minToUse;
             this.limitBeta = true;
             this.beta = this.beta;
         };
@@ -94,7 +116,8 @@ class FocusCameraImp {
             const maxArray = max.array;
             for (let i = 0; i < 3; i++) {
                 if (minArray[i] > maxArray[i]) {
-                    throw new Error("[Orbit Camera] Min target must be less than the max target");
+                    console.warn("[Orbit Camera] Target limit min's components must all be <= the max. Limits not set");
+                    return;
                 }
             }
             this.maxTargetPosition = max;
@@ -166,23 +189,29 @@ class FocusCameraImp {
         return this.memoizedAlpha.val;
     }
     set alpha(val) {
-        let clampedVal = this.clampAngle(val);
+        let valToUse = val;
         if (this.limitAlpha) {
-            clampedVal = Math.min(clampedVal, this.maxAlpha);
-            clampedVal = Math.max(clampedVal, this.minAlpha);
+            valToUse = Math.min(valToUse, this.maxAlpha);
+            valToUse = Math.max(valToUse, this.minAlpha);
+        }
+        else {
+            valToUse = this.clampAngle(val);
         }
-        this.memoizedAlpha.val = clampedVal;
+        this.memoizedAlpha.val = valToUse;
     }
     get beta() {
         return this.memoizedBeta.val;
     }
     set beta(val) {
-        let clampedVal = this.clampAngle(val);
+        let valToUse = val;
         if (this.limitBeta) {
-            clampedVal = Math.min(clampedVal, this.maxBeta);
-            clampedVal = Math.max(clampedVal, this.minBeta);
+            valToUse = Math.min(valToUse, this.maxBeta);
+            valToUse = Math.max(valToUse, this.minBeta);
+        }
+        else {
+            valToUse = this.clampAngle(val);
         }
-        this.memoizedBeta.val = clampedVal;
+        this.memoizedBeta.val = valToUse;
     }
     get radius() {
         return this.memoizedRadius.val;

package/lib/Entities/QuestionChallenge.js

@@ -26,7 +26,7 @@ class QuestionChallengeImp {
         };
         this.addAnswer = (answer) => {
             if (this.answerLookup.has(answer.id)) {
-                throw new Error(`Answer with ID ${answer.id} already exists`);
+                console.warn(`Answer with ID ${answer.id} already exists. Overwriting`);
             }
             this.answerLookup.set(answer.id, answer);
             this.reset();

package/lib/Entities/StateMachine.d.ts

@@ -1,3 +1,4 @@
+import { Result } from "../ValueObjects";
 export interface SerializedStates {
     version: number;
     systems: SystemState[];
@@ -17,9 +18,9 @@ export interface SerializedSystem {
 export interface StateMachine {
     transitionEaseFunction: (normalizedTime: number) => number;
     getSerializedStates(): SerializedStates;
-    setSerializedStates(state: SerializedStates, transitionTime: number): void;
+    setSerializedStates(state: SerializedStates, transitionTime: number): Result<null, Error>;
     applySerializedStatesString: (state: string, duration?: number) => void;
     setDefaultState(transitionTime: number): void;
-    registerSerializedSystem(serializedSystem: SerializedSystem): void;
+    registerSerializedSystem(serializedSystem: SerializedSystem): Result<null, Error>;
 }
 export declare function makeStateMachine(): StateMachine;

package/lib/Entities/StateMachine.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeStateMachine = void 0;
+const ValueObjects_1 = require("../ValueObjects");
 function makeStateMachine() {
     return new StateMachineImp();
 }
@@ -29,9 +30,12 @@ class StateMachineImp {
         };
         this.registerSerializedSystem = (serializedSystem) => {
             if (this.serializedSystems.has(serializedSystem.name)) {
-                throw new Error(`[StateMachine] Duplicate stateable systems encountered: ${serializedSystem.name}`);
+                const err = new Error(`[StateMachine] Duplicate stateable systems encountered: ${serializedSystem.name}`);
+                console.error(err.message);
+                return ValueObjects_1.reject(err);
             }
             this.serializedSystems.set(serializedSystem.name, serializedSystem);
+            return ValueObjects_1.resolve(null);
         };
         this.getSerializedStates = () => {
             const systems = Array.from(this.serializedSystems.values());
@@ -66,10 +70,13 @@ class StateMachineImp {
                         system.applyDefaultState(duration);
                     }
                 });
+                return ValueObjects_1.resolve(null);
             }
             // Here is where we will add support for future versions
             else {
-                throw new Error(`[StateMachine] Unsupported sereialized state encountered: ${state.version}`);
+                const err = new Error(`[StateMachine] Unsupported sereialized state encountered: ${state.version}`);
+                console.error(err.message);
+                return ValueObjects_1.reject(err);
             }
         };
         this.setDefaultState = (duration) => {

package/lib/PresentationManagers/DevicePreviewPM.d.ts

@@ -11,3 +11,4 @@ export declare class DevicePreviewPM {
     dispose(): void;
     constructor(devicePreview: DevicePreview, updateView: (vm: DevicePreviewVM) => void);
 }
+export declare const defaultDevicePreviewVM: DevicePreviewVM;

package/lib/PresentationManagers/DevicePreviewPM.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DevicePreviewPM = void 0;
+exports.defaultDevicePreviewVM = exports.DevicePreviewPM = void 0;
 class DevicePreviewPM {
     constructor(devicePreview, updateView) {
         this.doUpdateView = () => {
@@ -23,3 +23,8 @@ class DevicePreviewPM {
     }
 }
 exports.DevicePreviewPM = DevicePreviewPM;
+exports.defaultDevicePreviewVM = {
+    x: 0,
+    y: 0,
+    useDevicePreview: false,
+};

package/lib/PresentationManagers/ShowBabylonInspectorPM.js

@@ -5,10 +5,12 @@ class ShowBabylonInspectorPM {
     constructor(babylon, updateView) {
         this.doUpdateView = () => {
             const showInspector = this.babylon.showInspector;
-            if (showInspector === this.lastSetState)
+            const hasCanvas = this.babylon.renderCanvas === undefined ? false : true;
+            const showBeShown = hasCanvas && showInspector;
+            if (showBeShown === this.lastSetState)
                 return;
-            this.updateView(showInspector);
-            this.lastSetState = showInspector;
+            this.updateView(showBeShown);
+            this.lastSetState = showBeShown;
         };
         this.babylon = babylon;
         this.updateView = updateView;

package/lib/UseCases/FocusCamera/PixelOrbitFocusCamera.js

@@ -8,7 +8,8 @@ class PixelOrbitFocusCamera {
         this.sensitivity = 0.5;
         this.doOrbit = (pixelPosition) => {
             if (!this.previousPixelPos) {
-                throw new Error("[PixelOrbitFocusCamera] You must initialize first!");
+                console.error("[PixelOrbitFocusCamera] You must initialize first!");
+                return;
             }
             const pixelChange = ValueObjects_1.Vector2.Subtract(pixelPosition, this.previousPixelPos);
             this.focusCamera.alpha += pixelChange.x * this.sensitivity;

package/lib/UseCases/FocusCamera/PixelPlanePanFocusCamera.js

@@ -8,7 +8,8 @@ class PixelPlanePanFocusCamera {
         this.babylon = babylon;
         this.doPan = (pixelPosition) => {
             if (!this.plane || !this.previousPixelPos) {
-                throw new Error("[PixelPlanePan_OrbitCamera] You must initialize first!");
+                console.error("[PixelPlanePan_OrbitCamera] You must initialize first!");
+                return;
             }
             const initialRay = this.babylon.sceneRay(this.previousPixelPos);
             const finalRay = this.babylon.sceneRay(pixelPosition);

package/lib/ValueObjects/Result.d.ts

@@ -0,0 +1,30 @@
+export declare type Result<T, E> = Resolved<T, E> | Rejected<T, E>;
+export declare const resolve: <T, E = never>(value: T) => Resolved<T, E>;
+export declare const reject: <T = never, E = unknown>(err: E) => Rejected<T, E>;
+interface IResult<T, E> {
+    isResolved: boolean;
+    isRejected: boolean;
+    value?: T;
+    error?: E;
+    then<A>(f: (t: T) => A): Result<A, E>;
+    catch<U>(f: (e: E) => U): Result<T, U>;
+}
+export declare class Rejected<T, E> implements IResult<T, E> {
+    readonly error: E;
+    readonly value: undefined;
+    get isResolved(): boolean;
+    get isRejected(): boolean;
+    then<A>(_f: (t: T) => A): Result<A, E>;
+    catch<U>(f: (e: E) => U): Result<T, U>;
+    constructor(error: E);
+}
+export declare class Resolved<T, E> implements IResult<T, E> {
+    readonly value: T;
+    readonly error: undefined;
+    get isResolved(): boolean;
+    get isRejected(): boolean;
+    then<A>(f: (t: T) => A): Result<A, E>;
+    catch<U>(_f: (e: E) => U): Result<T, U>;
+    constructor(value: T);
+}
+export {};

package/lib/ValueObjects/Result.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resolved = exports.Rejected = exports.reject = exports.resolve = void 0;
+const resolve = (value) => new Resolved(value);
+exports.resolve = resolve;
+const reject = (err) => new Rejected(err);
+exports.reject = reject;
+class Rejected {
+    constructor(error) {
+        this.value = undefined;
+        this.error = error;
+    }
+    get isResolved() {
+        return false;
+    }
+    get isRejected() {
+        return true;
+    }
+    then(_f) {
+        return exports.reject(this.error);
+    }
+    catch(f) {
+        return exports.reject(f(this.error));
+    }
+}
+exports.Rejected = Rejected;
+class Resolved {
+    constructor(value) {
+        this.error = undefined;
+        this.value = value;
+    }
+    get isResolved() {
+        return true;
+    }
+    get isRejected() {
+        return false;
+    }
+    then(f) {
+        return exports.resolve(f(this.value));
+    }
+    catch(_f) {
+        return exports.resolve(this.value);
+    }
+}
+exports.Resolved = Resolved;

package/lib/ValueObjects/index.d.ts

@@ -5,3 +5,4 @@ export * from "./Angle";
 export * from "./Vector3";
 export * from "./ParametricLine";
 export * from "./ParametricPlane";
+export * from "./Result";

package/lib/ValueObjects/index.js

@@ -17,3 +17,4 @@ __exportStar(require("./Angle"), exports);
 __exportStar(require("./Vector3"), exports);
 __exportStar(require("./ParametricLine"), exports);
 __exportStar(require("./ParametricPlane"), exports);
+__exportStar(require("./Result"), exports);

package/package.json

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