@vived/app 4.27.0 → 4.27.1

package/lib/Entities/MeshModel.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMeshModel = exports.MeshModel = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const MemoizedNumber_1 = require("./MemoizedNumber");
+const MemoizedString_1 = require("./MemoizedString");
+const MemoizedVector3_1 = require("./MemoizedVector3");
+const ModelObject_1 = require("./ModelObject");
+const ObservableEntity_1 = require("./ObservableEntity");
+class MeshModel extends ObservableEntity_1.ObservableEntity {
+}
+exports.MeshModel = MeshModel;
+function makeMeshModel() {
+    return new MeshModelImp();
+}
+exports.makeMeshModel = makeMeshModel;
+class MeshModelImp extends MeshModel {
+    constructor() {
+        super(...arguments);
+        this.objects = [];
+        this._modelFile = undefined;
+        this._memoizedVersion = new MemoizedNumber_1.MemoizedNumber(0, this.notify);
+        this._memoizedName = new MemoizedString_1.MemoizedString("", this.notify);
+        this._memoizedDescription = new MemoizedString_1.MemoizedString("", this.notify);
+        this._image = undefined;
+        this._memoizedBoundsMin = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._memoizedBoundsMax = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._memoizedDefaultPosition = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._defaultRotation = ValueObjects_1.Quaternion.Identity();
+        this._memoizedDefaultScale = new MemoizedNumber_1.MemoizedNumber(1, this.notify);
+        this._imageURL = undefined;
+    }
+    hasObject(id) {
+        return !!this.objects.find((obj) => obj.id === id);
+    }
+    getObjectById(id) {
+        return this.objects.find((obj) => obj.id === id);
+    }
+    getObjectByPath(path) {
+        let rVal;
+        this.objects.forEach((obj) => {
+            if (obj.meshPaths.includes(path)) {
+                rVal = obj;
+            }
+        });
+        return rVal;
+    }
+    addObject(object) {
+        object.addObserver(this.notify);
+        this.objects.push(object);
+        this.notify();
+    }
+    deleteObject(id) {
+        this.objects = this.objects.filter((obj) => {
+            if (obj.id === id) {
+                obj.removeObserver(this.notify);
+                return false;
+            }
+            return true;
+        });
+        this.notify();
+    }
+    get modelFile() {
+        return this._modelFile;
+    }
+    set modelFile(file) {
+        this._modelFile = file;
+        this.notify();
+    }
+    get version() {
+        return this._memoizedVersion.val;
+    }
+    set version(version) {
+        this._memoizedVersion.val = version;
+    }
+    get name() {
+        return this._memoizedName.val;
+    }
+    set name(name) {
+        this._memoizedName.val = name;
+    }
+    get description() {
+        return this._memoizedDescription.val;
+    }
+    set description(description) {
+        this._memoizedDescription.val = description;
+    }
+    get image() {
+        return this._image;
+    }
+    set image(image) {
+        if (!this._image && !image)
+            return;
+        if (this._image && image && this._image.size === image.size)
+            return;
+        this._image = image;
+        if (image === undefined) {
+            this._imageURL = undefined;
+        }
+        else {
+            this._imageURL = URL.createObjectURL(image);
+        }
+        this.notify();
+    }
+    get imageURL() {
+        return this._imageURL;
+    }
+    get bounds_min() {
+        return this._memoizedBoundsMin.val;
+    }
+    set bounds_min(bounds_min) {
+        this._memoizedBoundsMin.val = bounds_min;
+    }
+    get bounds_max() {
+        return this._memoizedBoundsMax.val;
+    }
+    set bounds_max(bounds_max) {
+        this._memoizedBoundsMax.val = bounds_max;
+    }
+    get defaultPosition() {
+        return this._memoizedDefaultPosition.val;
+    }
+    set defaultPosition(position) {
+        this._memoizedDefaultPosition.val = position;
+    }
+    get defaultRotation() {
+        return this._defaultRotation;
+    }
+    set defaultRotation(rotation) {
+        if (ValueObjects_1.Quaternion.Equal(this._defaultRotation, rotation))
+            return;
+        this._defaultRotation = rotation;
+        this.notify();
+    }
+    get defaultScale() {
+        return this._memoizedDefaultScale.val;
+    }
+    set defaultScale(scale) {
+        this._memoizedDefaultScale.val = scale;
+    }
+    getData() {
+        return {
+            version: this.version,
+            objects: this.objects.map((obj) => ({
+                id: obj.id,
+                label: obj.label,
+                meshPaths: [...obj.meshPaths],
+            })),
+            name: this.name,
+            description: this.description,
+            bounds_min: this.bounds_min,
+            bounds_max: this.bounds_max,
+            defaultPosition: this.defaultPosition,
+            defaultRotation: this.defaultRotation,
+            defaultScale: this.defaultScale,
+        };
+    }
+    setData(data) {
+        this.version = data.version;
+        data.objects.forEach((obj) => {
+            const modelObject = ModelObject_1.makeModelObject(obj.id);
+            modelObject.label = obj.label;
+            obj.meshPaths.forEach((path) => modelObject.addMeshPath(path));
+            this.addObject(modelObject);
+        });
+        this.name = data.name;
+        this.description = data.description;
+        this.bounds_min = data.bounds_min;
+        this.bounds_max = data.bounds_max;
+        this.defaultPosition = data.defaultPosition;
+        this.defaultRotation = data.defaultRotation;
+        this.defaultScale = data.defaultScale;
+    }
+}

package/lib/Entities/ModelObject.d.ts

@@ -0,0 +1,10 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class ModelObject extends ObservableEntity {
+    abstract readonly id: string;
+    abstract get label(): string;
+    abstract set label(label: string);
+    abstract get meshPaths(): string[];
+    abstract addMeshPath(path: string): void;
+    abstract removeMeshPath(path: string): void;
+}
+export declare function makeModelObject(id: string): ModelObject;

package/lib/Entities/ModelObject.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeModelObject = exports.ModelObject = void 0;
+const MemoizedString_1 = require("./MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+class ModelObject extends ObservableEntity_1.ObservableEntity {
+}
+exports.ModelObject = ModelObject;
+function makeModelObject(id) {
+    return new ModelObjectImp(id);
+}
+exports.makeModelObject = makeModelObject;
+class ModelObjectImp extends ModelObject {
+    constructor(id) {
+        super();
+        this.memoizedLabel = new MemoizedString_1.MemoizedString("", this.notify);
+        this._meshPaths = new Set([]);
+        this.id = id;
+    }
+    get label() {
+        return this.memoizedLabel.val;
+    }
+    set label(label) {
+        this.memoizedLabel.val = label;
+    }
+    get meshPaths() {
+        return Array.from(this._meshPaths);
+    }
+    addMeshPath(path) {
+        if (this._meshPaths.has(path)) {
+            return;
+        }
+        this._meshPaths.add(path);
+        this.notify();
+    }
+    removeMeshPath(path) {
+        if (this._meshPaths.has(path)) {
+            this._meshPaths.delete(path);
+            this.notify();
+        }
+    }
+}

package/lib/Entities/MouseInput.d.ts

@@ -0,0 +1,21 @@
+import { Vector2 } from "../ValueObjects";
+export interface MouseInputEvent {
+    position: Vector2;
+    button: number;
+    event: MouseEvent;
+}
+export interface MouseController {
+    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;
+    setEventElement: (eventElement: HTMLElement) => void;
+    clearInputElement: () => void;
+    registerController: (controller: MouseController) => void;
+    removeController: (controller: MouseController) => void;
+}
+export declare function makeMouseInput(): MouseInput;

package/lib/Entities/MouseInput.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMouseInput = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+function makeMouseInput() {
+    return new MouseInputImp();
+}
+exports.makeMouseInput = makeMouseInput;
+class MouseInputImp {
+    constructor() {
+        this.controllers = [];
+        this.maxClickMovement = 5; // pixels
+        this.isPressed = false;
+        this._eventElement = undefined;
+        this.setEventElement = (eventElement) => {
+            if (this._eventElement)
+                this.clearInputElement();
+            eventElement.addEventListener("mousedown", this.onMouseDown, false);
+            eventElement.addEventListener("mouseup", this.onMouseUp, false);
+            eventElement.addEventListener("mousemove", this.onMouseMove, false);
+            eventElement.addEventListener("mouseout", this.onMouseOut, false);
+            eventElement.addEventListener("wheel", this.onWheel, false);
+            this._eventElement = eventElement;
+        };
+        this.clearInputElement = () => {
+            if (!this._eventElement)
+                return;
+            this._eventElement.removeEventListener("mousedown", this.onMouseDown);
+            this._eventElement.removeEventListener("mouseup", this.onMouseUp);
+            this._eventElement.removeEventListener("mousemove", this.onMouseMove);
+            this._eventElement.removeEventListener("mouseout", this.onMouseOut);
+            this._eventElement.removeEventListener("wheel", this.onWheel);
+            this._eventElement = undefined;
+        };
+        this.registerController = (controller) => {
+            this.controllers.push(controller);
+        };
+        this.removeController = (controller) => {
+            const index = this.controllers.indexOf(controller);
+            if (index >= 0) {
+                this.controllers.splice(index, 1);
+            }
+        };
+        this.onMouseDown = (e) => {
+            const inputEvt = this.makeMouseInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onDown) {
+                    c.onDown(inputEvt);
+                }
+            });
+            this.isPressed = true;
+            this.pressEvent = e;
+        };
+        this.onMouseUp = (e) => {
+            const inputEvt = this.makeMouseInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onUp) {
+                    c.onUp(inputEvt);
+                }
+            });
+            this.isPressed = false;
+            if (!this.pressEvent)
+                return;
+            const deltaX = this.pressEvent.screenX - e.screenX;
+            const deltaY = this.pressEvent.screenY - e.screenY;
+            const delta = new ValueObjects_1.Vector2(deltaX, deltaY);
+            if (delta.magnitued < this.maxClickMovement) {
+                this.controllers.forEach((c) => {
+                    if (c.onClick) {
+                        c.onClick(inputEvt);
+                    }
+                });
+            }
+            this.pressEvent = undefined;
+        };
+        this.onMouseMove = (e) => {
+            const inputEvt = this.makeMouseInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onMove) {
+                    c.onMove(inputEvt);
+                }
+            });
+            if (!this.pressEvent)
+                return;
+            const deltaX = this.pressEvent.screenX - e.screenX;
+            const deltaY = this.pressEvent.screenY - e.screenY;
+            const delta = new ValueObjects_1.Vector2(deltaX, deltaY);
+            if (delta.magnitued > this.maxClickMovement) {
+                this.pressEvent = undefined;
+            }
+        };
+        this.onMouseOut = (e) => {
+            if (!this.isPressed)
+                return;
+            const inputEvt = this.makeMouseInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onUp) {
+                    c.onUp(inputEvt);
+                }
+            });
+            this.pressEvent = undefined;
+            this.isPressed = false;
+        };
+        this.onWheel = (e) => {
+            e.preventDefault();
+            const inputEvt = this.makeMouseInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onWheel) {
+                    c.onWheel(inputEvt);
+                }
+            });
+        };
+    }
+    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/ObservableEntityRepo.d.ts

@@ -0,0 +1,20 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare class ObservableEntityRepo<T extends ObservableEntity> extends ObservableEntity {
+    private entityLookup;
+    private onEntityAddedObservers;
+    addEntityAddedObserver: (observer: (addedEntity: T) => void) => void;
+    removeEntityAddedObserver: (observer: (addedEntity: T) => void) => void;
+    private onEntityRemovedObservers;
+    addEntityRemovedObserver: (observer: (removedEntity: T) => void) => void;
+    removeEntityRemovedObserver: (observer: (removedEntity: T) => void) => void;
+    has: (id: string) => boolean;
+    add: (id: string, entity: T) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    get: (id: string) => T | undefined;
+    getAll: () => T[];
+    set: (entities: {
+        id: string;
+        entity: T;
+    }[]) => void;
+}

package/lib/Entities/ObservableEntityRepo.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableEntityRepo = void 0;
+const ObservableEntity_1 = require("./ObservableEntity");
+const ObserverList_1 = require("./ObserverList");
+class ObservableEntityRepo extends ObservableEntity_1.ObservableEntity {
+    constructor() {
+        super(...arguments);
+        this.entityLookup = new Map();
+        this.onEntityAddedObservers = new ObserverList_1.ObserverList();
+        this.addEntityAddedObserver = (observer) => {
+            this.onEntityAddedObservers.add(observer);
+        };
+        this.removeEntityAddedObserver = (observer) => {
+            this.onEntityAddedObservers.remove(observer);
+        };
+        this.onEntityRemovedObservers = new ObserverList_1.ObserverList();
+        this.addEntityRemovedObserver = (observer) => {
+            this.onEntityRemovedObservers.add(observer);
+        };
+        this.removeEntityRemovedObserver = (observer) => {
+            this.onEntityRemovedObservers.remove(observer);
+        };
+        this.has = (id) => {
+            return this.entityLookup.has(id);
+        };
+        this.add = (id, entity) => {
+            const existing = this.entityLookup.get(id);
+            if (existing) {
+                existing.removeObserver(this.notify);
+            }
+            this.entityLookup.set(id, entity);
+            entity.addObserver(this.notify);
+            this.notify();
+            this.onEntityAddedObservers.notify(entity);
+        };
+        this.remove = (id) => {
+            const existing = this.entityLookup.get(id);
+            if (!existing)
+                return;
+            this.entityLookup.delete(id);
+            existing.removeObserver(this.notify);
+            this.notify();
+            this.onEntityRemovedObservers.notify(existing);
+        };
+        this.clear = () => {
+            if (this.entityLookup.size === 0)
+                return;
+            this.entityLookup.forEach((entity) => {
+                entity.removeObserver(this.notify);
+                this.onEntityRemovedObservers.notify(entity);
+            });
+            this.entityLookup.clear();
+            this.notify();
+        };
+        this.get = (id) => {
+            return this.entityLookup.get(id);
+        };
+        this.getAll = () => {
+            return Array.from(this.entityLookup.values());
+        };
+        this.set = (entities) => {
+            if (this.entityLookup.size === 0 && entities.length === 0) {
+                return;
+            }
+            this.entityLookup.forEach((entity) => {
+                entity.removeObserver(this.notify);
+                this.onEntityRemovedObservers.notify(entity);
+            });
+            this.entityLookup.clear();
+            entities.forEach((e) => {
+                this.entityLookup.set(e.id, e.entity);
+                e.entity.addObserver(this.notify);
+                this.onEntityAddedObservers.notify(e.entity);
+            });
+            this.notify();
+        };
+    }
+}
+exports.ObservableEntityRepo = ObservableEntityRepo;

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)) {
+                console.warn(`Answer with ID ${answer.id} already exists. Overwriting`);
+            }
+            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);
+    }
+}