@vived/app 2.15.6 → 2.17.0

package/lib/Entities/Babylon.d.ts

@@ -1,4 +1,4 @@
-import { ParametricLine, Vector2, Vector3 } from "../ValueObjects";
+import { ParametricLine, Result, Vector2, Vector3 } from "../ValueObjects";
 export declare type OnBabylonChange = () => void;
 export interface ScenePick {
     mouseRay: ParametricLine;
@@ -16,6 +16,8 @@ export interface Babylon {
     renderCanvas?: HTMLCanvasElement;
     scenePick: (pixelPos: Vector2) => ScenePick;
     sceneRay: (pixelPos: Vector2) => ParametricLine;
+    sceneObjectPick: (pixelPos: Vector2) => Result<string, SceneObjectPickErrors>;
+    makeSceneObjectMeta: (id: string) => object;
     updateCanvasSize: () => void;
     submitRenderCanvas: (canvas: HTMLCanvasElement) => void;
     clearRenderCanvas: () => void;
@@ -28,3 +30,13 @@ export interface Babylon {
     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.makeBabylon = void 0;
+exports.SceneObjectPickErrorNoID = exports.SceneObjectPickErrorNoPick = exports.SceneObjectPickErrorNoPicker = exports.makeBabylon = void 0;
 const ValueObjects_1 = require("../ValueObjects");
 const MemoizedBoolean_1 = require("./MemoizedBoolean");
 const MemoizedVector2_1 = require("./MemoizedVector2");
@@ -11,6 +11,7 @@ function makeBabylon() {
 exports.makeBabylon = makeBabylon;
 class BabylonImp {
     constructor() {
+        this._scenePickerHasBeenSet = false;
         this.scenePick = () => {
             console.warn("orignal scene picker");
             return {
@@ -73,10 +74,32 @@ class BabylonImp {
         };
         this.registerScenePicker = (picker) => {
             this.scenePick = picker;
+            this._scenePickerHasBeenSet = true;
         };
         this.registerSceneRayer = (rayer) => {
             this.sceneRay = rayer;
         };
+        this.sceneObjectPick = (pixelPos) => {
+            var _a;
+            if (!this._scenePickerHasBeenSet) {
+                return ValueObjects_1.reject(new SceneObjectPickErrorNoPicker());
+            }
+            const scenePick = this.scenePick(pixelPos);
+            if (!scenePick.hit) {
+                return ValueObjects_1.reject(new SceneObjectPickErrorNoPick());
+            }
+            if (!((_a = scenePick.objectPickMeta) === null || _a === void 0 ? void 0 : _a.hasOwnProperty("sceneObjectID"))) {
+                return ValueObjects_1.reject(new SceneObjectPickErrorNoID());
+            }
+            const sceneObjectId = scenePick.objectPickMeta.sceneObjectID;
+            if (!sceneObjectId) {
+                return ValueObjects_1.reject(new SceneObjectPickErrorNoID());
+            }
+            return ValueObjects_1.resolve(sceneObjectId);
+        };
+        this.makeSceneObjectMeta = (id) => {
+            return { sceneObjectID: id };
+        };
         this.memoizedShowInspector = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
         this.memoizedCanvasSize = new MemoizedVector2_1.MemoizedVector2(ValueObjects_1.Vector2.One(), this.observers.notify);
     }
@@ -96,3 +119,24 @@ class BabylonImp {
         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";
+    }
+}
+exports.SceneObjectPickErrorNoPick = SceneObjectPickErrorNoPick;
+class SceneObjectPickErrorNoID extends Error {
+    constructor() {
+        super();
+        this.message = "Picked object does not have a scene ID";
+    }
+}
+exports.SceneObjectPickErrorNoID = SceneObjectPickErrorNoID;

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/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/Utilities/lerpNumber.d.ts

@@ -0,0 +1 @@
+export declare function lerpNumber(start: number, end: number, percent: number, clamp?: boolean): number;

package/lib/Utilities/lerpNumber.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lerpNumber = void 0;
+function lerpNumber(start, end, percent, clamp = false) {
+    const range = end - start;
+    if (!clamp) {
+        return percent * range + start;
+    }
+    let clampedP = percent;
+    if (clampedP < 0) {
+        clampedP = 0;
+    }
+    else if (clampedP > 1) {
+        clampedP = 1;
+    }
+    return clampedP * range + start;
+}
+exports.lerpNumber = lerpNumber;

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/Vector3.d.ts

@@ -15,6 +15,7 @@ export declare class Vector3 {
     static Cross: (a: Vector3, b: Vector3) => Vector3;
     static Dot: (a: Vector3, b: Vector3) => number;
     static NewVectorOfLength: (vec: Vector3, length: number) => Vector3;
+    static Lerp: (initial: Vector3, final: Vector3, percent: number) => Vector3;
     readonly x: number;
     readonly y: number;
     readonly z: number;

package/lib/ValueObjects/Vector3.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vector3 = void 0;
+const lerpNumber_1 = require("../Utilities/lerpNumber");
 class Vector3 {
     constructor(x, y, z) {
         this.x = x;
@@ -89,3 +90,9 @@ Vector3.NewVectorOfLength = (vec, length) => {
     const unit = vec.unit;
     return new Vector3(length * unit.x, length * unit.y, length * unit.z);
 };
+Vector3.Lerp = (initial, final, percent) => {
+    const x = lerpNumber_1.lerpNumber(initial.x, final.x, percent);
+    const y = lerpNumber_1.lerpNumber(initial.y, final.y, percent);
+    const z = lerpNumber_1.lerpNumber(initial.z, final.z, percent);
+    return new Vector3(x, y, z);
+};

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.6",
+  "version": "2.17.0",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",