@vived/app 2.12.0 → 2.15.2

package/lib/Entities/Babylon.js

@@ -78,7 +78,7 @@ class BabylonImp {
             this.sceneRay = rayer;
         };
         this.memoizedShowInspector = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
-        this.memoizedCanvasSize = new MemoizedVector2_1.MemoizedVector2(ValueObjects_1.Vector2.one(), this.observers.notify);
+        this.memoizedCanvasSize = new MemoizedVector2_1.MemoizedVector2(ValueObjects_1.Vector2.One(), this.observers.notify);
     }
     get showInspector() {
         return this.memoizedShowInspector.val;

package/lib/Entities/FocusCamera.js

@@ -14,7 +14,7 @@ class FocusCameraImp {
         this.defaultAlpha = 0;
         this.defaultBeta = 30;
         this.defaultRadius = 8;
-        this.defaultTarget = ValueObjects_1.Vector3.zero();
+        this.defaultTarget = ValueObjects_1.Vector3.Zero();
         this.limitRadius = false;
         this.minRadius = 0;
         this.maxRadius = 0;
@@ -25,13 +25,13 @@ class FocusCameraImp {
         this.minBeta = 0;
         this.maxBeta = 0;
         this.limitTarget = false;
-        this.maxTargetPosition = ValueObjects_1.Vector3.zero();
-        this.minTargetPosition = ValueObjects_1.Vector3.zero();
+        this.maxTargetPosition = ValueObjects_1.Vector3.Zero();
+        this.minTargetPosition = ValueObjects_1.Vector3.Zero();
         this.observers = new _1.ObserverList();
         this.memoizedAlpha = new _1.MemoizedNumber(0, this.observers.notify);
         this.memoizedBeta = new _1.MemoizedNumber(0, this.observers.notify);
         this.memoizedRadius = new _1.MemoizedNumber(1, this.observers.notify);
-        this.memoizedTarget = new _1.MemoizedVector3(ValueObjects_1.Vector3.zero(), this.observers.notify);
+        this.memoizedTarget = new _1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.observers.notify);
         this.setRadiusLimits = (min, max) => {
             if (min < 0) {
                 throw new Error("[Orbit Camera] Mininum Radius must be greater >= 0");
@@ -103,8 +103,8 @@ class FocusCameraImp {
             this.target = this.target;
         };
         this.clearTargetLimits = () => {
-            this.maxTargetPosition = ValueObjects_1.Vector3.zero();
-            this.minTargetPosition = ValueObjects_1.Vector3.zero();
+            this.maxTargetPosition = ValueObjects_1.Vector3.Zero();
+            this.minTargetPosition = ValueObjects_1.Vector3.Zero();
             this.limitTarget = false;
         };
         this.registerLerp = (lerper) => {
@@ -210,7 +210,7 @@ class FocusCameraImp {
                 targetVals[i] = v;
             }
         }
-        this.memoizedTarget.val = ValueObjects_1.Vector3.fromArray(targetVals);
+        this.memoizedTarget.val = ValueObjects_1.Vector3.FromArray(targetVals);
     }
     get direction() {
         const yLength = -Math.sin(this.degToRad(this.beta));
@@ -221,8 +221,8 @@ class FocusCameraImp {
         return new ValueObjects_1.Vector3(xLength, yLength, zLength);
     }
     get cameraPosition() {
-        const localOffset = ValueObjects_1.Vector3.newVectorOfLength(this.direction, -this.radius);
-        return ValueObjects_1.Vector3.add(this.target, localOffset);
+        const localOffset = ValueObjects_1.Vector3.NewVectorOfLength(this.direction, -this.radius);
+        return ValueObjects_1.Vector3.Add(this.target, localOffset);
     }
     degToRad(degrees) {
         return (degrees * Math.PI) / 180;

package/lib/Entities/MemoizedBoolean.d.ts

@@ -2,6 +2,7 @@ export declare class MemoizedBoolean {
     private _val;
     get val(): boolean;
     set val(b: boolean);
+    setValQuietly(val: boolean): void;
     private onChangeCallback;
     constructor(initialValue: boolean, onChangeCallback: () => void);
 }

package/lib/Entities/MemoizedBoolean.js

@@ -15,5 +15,8 @@ class MemoizedBoolean {
         this._val = b;
         this.onChangeCallback();
     }
+    setValQuietly(val) {
+        this._val = val;
+    }
 }
 exports.MemoizedBoolean = MemoizedBoolean;

package/lib/Entities/MemoizedNumber.d.ts

@@ -2,6 +2,7 @@ export declare class MemoizedNumber {
     private _val;
     get val(): number;
     set val(b: number);
+    setValQuietly(val: number): void;
     private onChangeCallback;
     constructor(initialValue: number, onChangeCallback: () => void);
 }

package/lib/Entities/MemoizedNumber.js

@@ -15,5 +15,8 @@ class MemoizedNumber {
         this._val = b;
         this.onChangeCallback();
     }
+    setValQuietly(val) {
+        this._val = val;
+    }
 }
 exports.MemoizedNumber = MemoizedNumber;

package/lib/Entities/MemoizedString.d.ts

@@ -2,6 +2,7 @@ export declare class MemoizedString {
     private _val;
     get val(): string;
     set val(b: string);
+    setValQuietly(val: string): void;
     private onChangeCallback;
     constructor(initialValue: string, onChangeCallback: () => void);
 }

package/lib/Entities/MemoizedString.js

@@ -15,5 +15,8 @@ class MemoizedString {
         this._val = b;
         this.onChangeCallback();
     }
+    setValQuietly(val) {
+        this._val = val;
+    }
 }
 exports.MemoizedString = MemoizedString;

package/lib/Entities/MemoizedVector2.d.ts

@@ -3,6 +3,7 @@ export declare class MemoizedVector2 {
     private _val;
     get val(): Vector2;
     set val(v: Vector2);
+    setValQuietly(val: Vector2): void;
     private onChangeCallback;
     constructor(initialValue: Vector2, onChangeCallback: () => void);
 }

package/lib/Entities/MemoizedVector2.js

@@ -11,10 +11,13 @@ class MemoizedVector2 {
         return this._val;
     }
     set val(v) {
-        if (ValueObjects_1.Vector2.equal(v, this._val))
+        if (ValueObjects_1.Vector2.Equal(v, this._val))
             return;
         this._val = v;
         this.onChangeCallback();
     }
+    setValQuietly(val) {
+        this._val = val;
+    }
 }
 exports.MemoizedVector2 = MemoizedVector2;

package/lib/Entities/MemoizedVector3.d.ts

@@ -3,6 +3,7 @@ export declare class MemoizedVector3 {
     private _val;
     get val(): Vector3;
     set val(v: Vector3);
+    setValQuietly(val: Vector3): void;
     private onChangeCallback;
     constructor(initialValue: Vector3, onChangeCallback: () => void);
 }

package/lib/Entities/MemoizedVector3.js

@@ -11,10 +11,13 @@ class MemoizedVector3 {
         return this._val;
     }
     set val(v) {
-        if (Vector3_1.Vector3.equal(v, this._val))
+        if (Vector3_1.Vector3.Equal(v, this._val))
             return;
         this._val = v;
         this.onChangeCallback();
     }
+    setValQuietly(val) {
+        this._val = val;
+    }
 }
 exports.MemoizedVector3 = MemoizedVector3;

package/lib/Entities/MouseInput.d.ts

@@ -1,9 +1,15 @@
+import { Vector2 } from "../ValueObjects";
+export interface MouseInputEvent {
+    position: Vector2;
+    button: number;
+    event: MouseEvent;
+}
 export interface MouseController {
-    onClick?: (e: MouseEvent) => void;
-    onDown?: (e: MouseEvent) => void;
-    onUp?: (e: MouseEvent) => void;
-    onMove?: (e: MouseEvent) => void;
-    onWheel?: (e: WheelEvent) => void;
+    onClick?: (e: MouseInputEvent) => void;
+    onDown?: (e: MouseInputEvent) => void;
+    onUp?: (e: MouseInputEvent) => void;
+    onMove?: (e: MouseInputEvent) => void;
+    onWheel?: (e: MouseInputEvent) => void;
 }
 export interface MouseInput {
     eventElement: HTMLElement | undefined;

package/lib/Entities/MouseInput.js

@@ -43,9 +43,10 @@ class MouseInputImp {
         };
         this.onMouseDown = (e) => {
             e.preventDefault();
+            const inputEvt = this.makeMouseInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onDown) {
-                    c.onDown(e);
+                    c.onDown(inputEvt);
                 }
             });
             this.isPressed = true;
@@ -53,9 +54,10 @@ class MouseInputImp {
         };
         this.onMouseUp = (e) => {
             e.preventDefault();
+            const inputEvt = this.makeMouseInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onUp) {
-                    c.onUp(e);
+                    c.onUp(inputEvt);
                 }
             });
             this.isPressed = false;
@@ -67,7 +69,7 @@ class MouseInputImp {
             if (delta.magnitued < this.maxClickMovement) {
                 this.controllers.forEach((c) => {
                     if (c.onClick) {
-                        c.onClick(e);
+                        c.onClick(inputEvt);
                     }
                 });
             }
@@ -75,9 +77,10 @@ class MouseInputImp {
         };
         this.onMouseMove = (e) => {
             e.preventDefault();
+            const inputEvt = this.makeMouseInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onMove) {
-                    c.onMove(e);
+                    c.onMove(inputEvt);
                 }
             });
             if (!this.pressEvent)
@@ -93,9 +96,10 @@ class MouseInputImp {
             e.preventDefault();
             if (!this.isPressed)
                 return;
+            const inputEvt = this.makeMouseInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onUp) {
-                    c.onUp(e);
+                    c.onUp(inputEvt);
                 }
             });
             this.pressEvent = undefined;
@@ -103,9 +107,10 @@ class MouseInputImp {
         };
         this.onWheel = (e) => {
             e.preventDefault();
+            const inputEvt = this.makeMouseInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onWheel) {
-                    c.onWheel(e);
+                    c.onWheel(inputEvt);
                 }
             });
         };
@@ -113,4 +118,14 @@ class MouseInputImp {
     get eventElement() {
         return this._eventElement;
     }
+    makeMouseInputEvent(event) {
+        const px = event.offsetX;
+        const py = event.offsetY;
+        const button = event.button;
+        return {
+            position: new ValueObjects_1.Vector2(px, py),
+            button,
+            event,
+        };
+    }
 }

package/lib/Entities/QuestionChallenge.d.ts

@@ -0,0 +1,21 @@
+import { QuestionChallengeAnswer } from "./QuestionChallengeAnswer";
+export declare type OnQuestionChallengeChange = () => void;
+export interface QuestionChallenge {
+    gotItRight: boolean;
+    tries: number;
+    text: string;
+    addAnswer: (answer: QuestionChallengeAnswer) => void;
+    removeAnswer: (id: string) => void;
+    getAnswer: (id: string) => QuestionChallengeAnswer | undefined;
+    getAllAnswers: () => QuestionChallengeAnswer[];
+    hasAnswer: (id: string) => boolean;
+    createAnswer: (text: string) => QuestionChallengeAnswer;
+    removeAllAnswers: () => void;
+    setDefaultState: () => void;
+    reset: () => void;
+    submitAnswer: (id: string) => void;
+    setIDGenerator: (generator: () => string) => void;
+    addObserver: (observer: OnQuestionChallengeChange) => void;
+    removeObserver: (observer: OnQuestionChallengeChange) => void;
+}
+export declare function makeQuestionChallenge(): QuestionChallenge;

package/lib/Entities/QuestionChallenge.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeQuestionChallenge = void 0;
+const _1 = require(".");
+const QuestionChallengeAnswer_1 = require("./QuestionChallengeAnswer");
+function makeQuestionChallenge() {
+    return new QuestionChallengeImp();
+}
+exports.makeQuestionChallenge = makeQuestionChallenge;
+class QuestionChallengeImp {
+    constructor() {
+        this.answerLookup = new Map();
+        this.observers = new _1.ObserverList();
+        this._tries = 0;
+        this._gotItRight = false;
+        this.memoizedText = new _1.MemoizedString("", this.observers.notify);
+        this.generateID = () => {
+            const randomNumber = Math.random() * Date.now();
+            return `${randomNumber}`;
+        };
+        this.setIDGenerator = (generator) => {
+            this.generateID = generator;
+        };
+        this.getAllAnswers = () => {
+            return Array.from(this.answerLookup.values());
+        };
+        this.addAnswer = (answer) => {
+            if (this.answerLookup.has(answer.id)) {
+                throw new Error(`Answer with ID ${answer.id} already exists`);
+            }
+            this.answerLookup.set(answer.id, answer);
+            this.reset();
+        };
+        this.removeAnswer = (id) => {
+            const answer = this.answerLookup.get(id);
+            if (!answer)
+                return;
+            this.answerLookup.delete(id);
+            this.reset();
+        };
+        this.getAnswer = (id) => {
+            return this.answerLookup.get(id);
+        };
+        this.hasAnswer = (id) => {
+            return this.answerLookup.has(id);
+        };
+        this.reset = () => {
+            this._gotItRight = false;
+            this._tries = 0;
+            this.answerLookup.forEach((ans) => (ans.showFeedback = false));
+            this.observers.notify();
+        };
+        this.submitAnswer = (id) => {
+            const ans = this.getAnswer(id);
+            if (!ans) {
+                console.warn(`[Question Challenge] Unable to find answer by ID:  ${id}`);
+                return;
+            }
+            this._tries++;
+            ans.showFeedback = true;
+            this._gotItRight = ans.isCorrect;
+            this.observers.notify();
+        };
+        this.createAnswer = (text) => {
+            const id = this.generateID();
+            const answer = QuestionChallengeAnswer_1.makeQuestionChallengeAnswer(id);
+            answer.text = text;
+            this.addAnswer(answer);
+            return answer;
+        };
+        this.removeAllAnswers = () => {
+            const allAnswers = Array.from(this.answerLookup.keys());
+            allAnswers.forEach((id) => this.removeAnswer(id));
+            this.reset();
+        };
+        this.setDefaultState = () => {
+            this.removeAllAnswers();
+            const trueAnswer = this.createAnswer("True");
+            trueAnswer.isCorrect = true;
+            this.createAnswer("False");
+            this.memoizedText.setValQuietly("True / False question text");
+            this.reset();
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get tries() {
+        return this._tries;
+    }
+    get gotItRight() {
+        return this._gotItRight;
+    }
+    get text() {
+        return this.memoizedText.val;
+    }
+    set text(val) {
+        this.memoizedText.val = val;
+    }
+}

package/lib/Entities/QuestionChallengeAnswer.d.ts

@@ -0,0 +1,32 @@
+export declare type OnQuestionAnswerChange = () => void;
+export interface QuestionChallengeAnswer {
+    id: string;
+    text: string;
+    isCorrect: boolean;
+    feedbackText: string;
+    showFeedback: boolean;
+    addObserver(observer: OnQuestionAnswerChange): void;
+    removeObserver(observer: OnQuestionAnswerChange): void;
+}
+export declare function makeQuestionChallengeAnswer(id: string): QuestionChallengeAnswerImp;
+declare class QuestionChallengeAnswerImp implements QuestionChallengeAnswer {
+    private observers;
+    private _id;
+    get id(): string;
+    private memoizedText;
+    get text(): string;
+    set text(val: string);
+    private memoizedFeedback;
+    get feedbackText(): string;
+    set feedbackText(val: string);
+    private memoizedIsCorrect;
+    get isCorrect(): boolean;
+    set isCorrect(val: boolean);
+    private memoizedShowFeedback;
+    get showFeedback(): boolean;
+    set showFeedback(val: boolean);
+    addObserver(observer: OnQuestionAnswerChange): void;
+    removeObserver(observer: OnQuestionAnswerChange): void;
+    constructor(id: string);
+}
+export {};

package/lib/Entities/QuestionChallengeAnswer.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeQuestionChallengeAnswer = void 0;
+const _1 = require(".");
+function makeQuestionChallengeAnswer(id) {
+    return new QuestionChallengeAnswerImp(id);
+}
+exports.makeQuestionChallengeAnswer = makeQuestionChallengeAnswer;
+class QuestionChallengeAnswerImp {
+    constructor(id) {
+        this.observers = new _1.ObserverList();
+        this.memoizedText = new _1.MemoizedString("Answer", this.observers.notify);
+        this.memoizedFeedback = new _1.MemoizedString("", this.observers.notify);
+        this.memoizedIsCorrect = new _1.MemoizedBoolean(false, this.observers.notify);
+        this.memoizedShowFeedback = new _1.MemoizedBoolean(false, this.observers.notify);
+        this._id = id;
+    }
+    get id() {
+        return this._id;
+    }
+    get text() {
+        return this.memoizedText.val;
+    }
+    set text(val) {
+        this.memoizedText.val = val;
+    }
+    get feedbackText() {
+        return this.memoizedFeedback.val;
+    }
+    set feedbackText(val) {
+        this.memoizedFeedback.val = val;
+    }
+    get isCorrect() {
+        return this.memoizedIsCorrect.val;
+    }
+    set isCorrect(val) {
+        this.memoizedIsCorrect.val = val;
+    }
+    get showFeedback() {
+        return this.memoizedShowFeedback.val;
+    }
+    set showFeedback(val) {
+        this.memoizedShowFeedback.val = val;
+    }
+    addObserver(observer) {
+        this.observers.add(observer);
+    }
+    removeObserver(observer) {
+        this.observers.remove(observer);
+    }
+}

package/lib/Entities/TouchInput.d.ts

@@ -1,9 +1,20 @@
 import { Vector2 } from "../ValueObjects";
+export interface TouchInputEvent {
+    touchCount: number;
+    touchCenter: Vector2;
+    touches: TouchData[];
+    event: TouchEvent;
+}
+export interface TouchData {
+    id: number;
+    position: Vector2;
+    touch?: Touch;
+}
 export interface TouchController {
-    onTouchStart?: (e: TouchEvent) => void;
-    onTouchMove?: (e: TouchEvent) => void;
-    onTouchEnd?: (e: TouchEvent) => void;
-    onTouchCancel?: (e: TouchEvent) => void;
+    onTouchStart?: (e: TouchInputEvent) => void;
+    onTouchMove?: (e: TouchInputEvent) => void;
+    onTouchEnd?: (e: TouchInputEvent) => void;
+    onTouchCancel?: (e: TouchInputEvent) => void;
 }
 export interface TouchInput {
     eventElement: HTMLElement | undefined;
@@ -11,9 +22,6 @@ export interface TouchInput {
     setEventElement: (eventElement: HTMLElement) => void;
     clearInputElement: () => void;
     updateInputElementBounds: () => void;
-    getTouchOffsetPosition: (touch: Touch) => Vector2;
-    getDistatnceBetweenTouches: (touch1: Touch, touch2: Touch) => number;
-    getTouchsCenter: (touches: TouchList) => Vector2;
     registerController: (controller: TouchController) => void;
     removeController: (controller: TouchController) => void;
 }

package/lib/Entities/TouchInput.js

@@ -24,26 +24,6 @@ class TouchInputImp {
             const y = touch.clientY - this.eventElementBounds.y;
             return new ValueObjects_1.Vector2(x, y);
         };
-        this.getDistatnceBetweenTouches = (touch1, touch2) => {
-            const t1 = this.getTouchOffsetPosition(touch1);
-            const t2 = this.getTouchOffsetPosition(touch2);
-            const delta = ValueObjects_1.Vector2.subtract(t2, t2);
-            return delta.magnitued;
-        };
-        this.getTouchsCenter = (touches) => {
-            const touchCount = touches.length;
-            if (touchCount === 0)
-                return ValueObjects_1.Vector2.zero();
-            let sumX = 0;
-            let sumY = 0;
-            for (let i = 0; i < touchCount; i++) {
-                const touch = touches[i];
-                const touchPos = this.getTouchOffsetPosition(touch);
-                sumX += touchPos.x;
-                sumY += touchPos.y;
-            }
-            return new ValueObjects_1.Vector2(sumX / touches.length, sumY / touches.length);
-        };
         this.setEventElement = (eventElement) => {
             if (this._eventElement)
                 this.clearInputElement();
@@ -56,33 +36,37 @@ class TouchInputImp {
         };
         this.onTouchStart = (e) => {
             e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onTouchStart) {
-                    c.onTouchStart(e);
+                    c.onTouchStart(touchInput);
                 }
             });
         };
         this.onTouchMove = (e) => {
             e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onTouchMove) {
-                    c.onTouchMove(e);
+                    c.onTouchMove(touchInput);
                 }
             });
         };
         this.onTouchEnd = (e) => {
             e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onTouchEnd) {
-                    c.onTouchEnd(e);
+                    c.onTouchEnd(touchInput);
                 }
             });
         };
         this.onTouchCancel = (e) => {
             e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onTouchCancel) {
-                    c.onTouchCancel(e);
+                    c.onTouchCancel(touchInput);
                 }
             });
         };
@@ -108,4 +92,49 @@ class TouchInputImp {
     get eventElement() {
         return this._eventElement;
     }
+    createTouchInputEvent(event) {
+        const touches = [];
+        const touchCount = event.touches.length;
+        let minX = 0;
+        let maxX = 0;
+        let minY = 0;
+        let maxY = 0;
+        for (let i = 0; i < touchCount; i++) {
+            const touch = event.touches[i];
+            const position = this.getTouchOffsetPosition(touch);
+            touches.push({
+                id: touch.identifier,
+                touch,
+                position,
+            });
+            if (i === 0) {
+                minX = position.x;
+                maxX = position.x;
+                minY = position.y;
+                maxY = position.y;
+            }
+            else {
+                minX = Math.min(minX, position.x);
+                maxX = Math.max(maxX, position.x);
+                minY = Math.min(minY, position.y);
+                maxY = Math.max(maxY, position.y);
+            }
+        }
+        let cntX = 0;
+        let cntY = 0;
+        if (touchCount === 1) {
+            cntX = maxX;
+            cntY = maxY;
+        }
+        else {
+            cntX = minX + (maxX - minX) / 2;
+            cntY = minY + (maxY - minY) / 2;
+        }
+        return {
+            touchCenter: new ValueObjects_1.Vector2(cntX, cntY),
+            touchCount,
+            touches,
+            event,
+        };
+    }
 }

package/lib/Entities/index.d.ts

@@ -13,3 +13,5 @@ export * from "./StateMachine";
 export * from "./UndoRedo";
 export * from "./MouseInput";
 export * from "./TouchInput";
+export * from "./QuestionChallengeAnswer";
+export * from "./QuestionChallenge";

package/lib/Entities/index.js

@@ -25,3 +25,5 @@ __exportStar(require("./StateMachine"), exports);
 __exportStar(require("./UndoRedo"), exports);
 __exportStar(require("./MouseInput"), exports);
 __exportStar(require("./TouchInput"), exports);
+__exportStar(require("./QuestionChallengeAnswer"), exports);
+__exportStar(require("./QuestionChallenge"), exports);