@vived/app 4.27.1 → 4.28.0

package/lib/Components/LabelDrop/PM/RemainingLabelDropListPM.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRemainingLabelDropListPM = exports.RemainingLabelDropListPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+class RemainingLabelDropListPM extends AppObject_1.AppObjectPM {
+}
+exports.RemainingLabelDropListPM = RemainingLabelDropListPM;
+RemainingLabelDropListPM.type = "RemainingLabelDropListPM";
+RemainingLabelDropListPM.get = (appObjects) => AppObject_1.getSingletonComponent(RemainingLabelDropListPM.type, appObjects);
+function makeRemainingLabelDropListPM(appObject) {
+    return new RemainingLabelDropListPMImp(appObject);
+}
+exports.makeRemainingLabelDropListPM = makeRemainingLabelDropListPM;
+class RemainingLabelDropListPMImp extends RemainingLabelDropListPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, RemainingLabelDropListPM.type);
+        this.onEntityChange = () => {
+            if (!this.labelDropRepo)
+                return;
+            const labelDropIds = this.labelDropRepo.getRemainingLabelDrops();
+            const items = this.labelDropRepo.getAll();
+            const datas = [];
+            items.forEach((item) => {
+                if (labelDropIds.includes(item.id)) {
+                    datas.push({
+                        id: item.id,
+                        label: item.labelEntity.display,
+                    });
+                }
+            });
+            this.doUpdateView(datas);
+        };
+        (_a = this.labelDropRepo) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        this.appObjects.registerSingleton(this);
+        this.onEntityChange();
+    }
+    get labelDropRepo() {
+        return this.getCachedSingleton(LabelDropRepo_1.LabelDropRepo.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        let vmsEqual = true;
+        for (let i = 0; i < a.length; i++) {
+            if (a[i].id !== b[i].id) {
+                vmsEqual = false;
+            }
+            else if (a[i].label !== b[i].label) {
+                vmsEqual = false;
+            }
+        }
+        return vmsEqual;
+    }
+}

package/lib/Components/LabelDrop/PM/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./LabelDropDragItemPM";
+export * from "./LabelDropEditingIDPM";
+export * from "./LabelDropListPM";
+export * from "./LabelDropReviewPM";
+export * from "./LabelDropTargetsPM";
+export * from "./RemainingLabelDropListPM";

package/lib/Components/LabelDrop/PM/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LabelDropDragItemPM"), exports);
+__exportStar(require("./LabelDropEditingIDPM"), exports);
+__exportStar(require("./LabelDropListPM"), exports);
+__exportStar(require("./LabelDropReviewPM"), exports);
+__exportStar(require("./LabelDropTargetsPM"), exports);
+__exportStar(require("./RemainingLabelDropListPM"), exports);

package/lib/Components/LabelDrop/UseCases/CorrectAnimationUC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { LabelDropAnimationI } from "./LabelDropAnimation";
+export declare abstract class LabelDropCorrectAnimationUC extends AppObjectUC implements LabelDropAnimationI {
+    abstract feedbackDurationMS: number;
+    abstract fadeDurationMS: number;
+    abstract getIsAnimating(): boolean;
+    abstract start: () => Promise<boolean>;
+    abstract cancel: () => void;
+    static type: string;
+    static get(appObject: AppObjectRepo): LabelDropCorrectAnimationUC | undefined;
+}
+export declare function makeLabelDropCorrectAnimationUC(appObject: AppObject): LabelDropCorrectAnimationUC;

package/lib/Components/LabelDrop/UseCases/CorrectAnimationUC.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLabelDropCorrectAnimationUC = exports.LabelDropCorrectAnimationUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+class LabelDropCorrectAnimationUC extends AppObject_1.AppObjectUC {
+    static get(appObject) {
+        return AppObject_1.getSingletonComponent(LabelDropCorrectAnimationUC.type, appObject);
+    }
+}
+exports.LabelDropCorrectAnimationUC = LabelDropCorrectAnimationUC;
+LabelDropCorrectAnimationUC.type = "LabelDropCorrectAnimation";
+function makeLabelDropCorrectAnimationUC(appObject) {
+    return new LabelDropCorrectAnimationUCImp(appObject);
+}
+exports.makeLabelDropCorrectAnimationUC = makeLabelDropCorrectAnimationUC;
+class LabelDropCorrectAnimationUCImp extends LabelDropCorrectAnimationUC {
+    constructor(appObject) {
+        super(appObject, LabelDropCorrectAnimationUC.type);
+        this.feedbackDurationMS = 1000;
+        this.fadeDurationMS = 200;
+        this._isAnimating = false;
+        this.intervalDeltaMS = 10;
+        this.cancelAnimation = false;
+        this.start = () => {
+            if (!this.labelDropEntity) {
+                return Promise.reject(new Error("No label drop entity"));
+            }
+            return new Promise((resolve) => {
+                const startTime = Date.now();
+                const fadeStartTime = startTime + this.feedbackDurationMS;
+                const endTime = startTime + this.fadeDurationMS + this.feedbackDurationMS;
+                this._isAnimating = true;
+                const interval = setInterval(() => {
+                    if (!this.labelDropEntity)
+                        return;
+                    if (this.cancelAnimation) {
+                        clearInterval(interval);
+                        this.cancelAnimation = false;
+                        resolve(false);
+                        return;
+                    }
+                    const currentTime = Date.now();
+                    if (currentTime >= endTime || this.cancelAnimation) {
+                        this._isAnimating = false;
+                        this.labelDropEntity.dragAlpha = 0;
+                        clearInterval(interval);
+                        resolve(true);
+                    }
+                    else if (currentTime >= fadeStartTime) {
+                        const fadePercent = (currentTime - fadeStartTime) / this.fadeDurationMS;
+                        this.labelDropEntity.dragAlpha = 1 - fadePercent;
+                    }
+                }, this.intervalDeltaMS);
+            });
+        };
+        this.cancel = () => {
+            if (!this.getIsAnimating) {
+                return;
+            }
+            this.cancelAnimation = true;
+        };
+        this.labelDropEntity = appObject.getComponent(LabelDropRepo_1.LabelDropRepo.type);
+        if (!this.labelDropEntity) {
+            this.error("UC added to an app object that does not have a LabelDropEntity");
+        }
+        this.appObjects.registerSingleton(this);
+    }
+    getIsAnimating() {
+        return this._isAnimating;
+    }
+}

package/lib/Components/LabelDrop/UseCases/DeleteAllLabelDropUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class DeleteAllLabelDropUC extends AppObjectUC {
+    static readonly type = "DeleteAllLabelDropUC";
+    abstract delete(): void;
+    static get(appObjects: AppObjectRepo): DeleteAllLabelDropUC | undefined;
+}
+export declare function makeDeleteAllLabelDropUC(appObject: AppObject): DeleteAllLabelDropUC;

package/lib/Components/LabelDrop/UseCases/DeleteAllLabelDropUC.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDeleteAllLabelDropUC = exports.DeleteAllLabelDropUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+class DeleteAllLabelDropUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(DeleteAllLabelDropUC.type, appObjects);
+    }
+}
+exports.DeleteAllLabelDropUC = DeleteAllLabelDropUC;
+DeleteAllLabelDropUC.type = "DeleteAllLabelDropUC";
+function makeDeleteAllLabelDropUC(appObject) {
+    return new DeleteAllLabelDropUCImp(appObject);
+}
+exports.makeDeleteAllLabelDropUC = makeDeleteAllLabelDropUC;
+class DeleteAllLabelDropUCImp extends DeleteAllLabelDropUC {
+    get repo() {
+        return this.getCachedSingleton(LabelDropRepo_1.LabelDropRepo.type);
+    }
+    get undo() {
+        return this.getCachedSingleton(UndoRedoEntity_1.UndoRedoEntity.type);
+    }
+    get dispatchStateChange() {
+        var _a;
+        return (_a = this.getCachedSingleton(DispatchStateChangeUC_1.DispatchStateChangeUC.type)) === null || _a === void 0 ? void 0 : _a.doDispatch;
+    }
+    delete() {
+        var _a;
+        const repo = this.repo;
+        const dispatchStateChange = this.dispatchStateChange;
+        if (!repo || !dispatchStateChange) {
+            this.error("Missing Component");
+            return;
+        }
+        const allData = repo.getAll().map((item) => item.data);
+        if (allData.length === 0)
+            return;
+        repo.deleteAllItems();
+        (_a = this.undo) === null || _a === void 0 ? void 0 : _a.submitAction({
+            undoAction: () => {
+                allData.forEach((data) => {
+                    repo.makeLabelDropItem(data.id).data = data;
+                });
+                dispatchStateChange();
+            },
+            redoAction: () => {
+                allData.forEach((data) => {
+                    repo.deleteItem(data.id);
+                });
+                dispatchStateChange();
+            }
+        });
+        dispatchStateChange();
+    }
+    constructor(appObject) {
+        super(appObject, DeleteAllLabelDropUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}

package/lib/Components/LabelDrop/UseCases/DeleteLabelDropUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class DeleteLabelDropUC extends AppObjectUC {
+    static readonly type = "DeleteLabelDropUC";
+    abstract deleteLabelDrop(id: string): void;
+    static get(appObjects: AppObjectRepo): DeleteLabelDropUC | undefined;
+}
+export declare function makeDeleteLabelDropUC(appObject: AppObject): DeleteLabelDropUC;

package/lib/Components/LabelDrop/UseCases/DeleteLabelDropUC.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDeleteLabelDropUC = exports.DeleteLabelDropUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+class DeleteLabelDropUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(DeleteLabelDropUC.type, appObjects);
+    }
+}
+exports.DeleteLabelDropUC = DeleteLabelDropUC;
+DeleteLabelDropUC.type = "DeleteLabelDropUC";
+function makeDeleteLabelDropUC(appObject) {
+    return new DeleteLabelDropUCImp(appObject);
+}
+exports.makeDeleteLabelDropUC = makeDeleteLabelDropUC;
+class DeleteLabelDropUCImp extends DeleteLabelDropUC {
+    get repo() {
+        return this.getCachedSingleton(LabelDropRepo_1.LabelDropRepo.type);
+    }
+    get undo() {
+        return this.getCachedSingleton(UndoRedoEntity_1.UndoRedoEntity.type);
+    }
+    get dispatchStateChange() {
+        var _a;
+        return (_a = this.getCachedSingleton(DispatchStateChangeUC_1.DispatchStateChangeUC.type)) === null || _a === void 0 ? void 0 : _a.doDispatch;
+    }
+    deleteLabelDrop(id) {
+        var _a, _b;
+        const repo = this.repo;
+        const dispatchStateChange = this.dispatchStateChange;
+        if (!repo || !dispatchStateChange) {
+            this.error("Missing Component");
+            return;
+        }
+        const data = (_a = repo.getForAppObject(id)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!data) {
+            this.appObjects.submitWarning("DeleteLabelDropUC", `Unable to find label drop for id: ${id}`);
+            return;
+        }
+        repo.deleteItem(id);
+        (_b = this.undo) === null || _b === void 0 ? void 0 : _b.submitAction({
+            undoAction: () => {
+                repo.makeLabelDropItem(id).data = data;
+                dispatchStateChange();
+            },
+            redoAction: () => {
+                repo.deleteItem(id);
+                dispatchStateChange();
+            }
+        });
+        repo.editingID = undefined;
+        dispatchStateChange();
+    }
+    constructor(appObject) {
+        super(appObject, DeleteLabelDropUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}

package/lib/Components/LabelDrop/UseCases/DragLabelDropUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { ParametricLine, Vector2 } from "../../../ValueObjects";
+export declare abstract class DragLabelDropUC extends AppObjectUC {
+    static readonly type = "DragLabelDropUC";
+    abstract initialize(labelDropID: string, pos: Vector2): void;
+    abstract setPosition2D(pos: Vector2): void;
+    abstract release(ray: ParametricLine): void;
+    abstract onFinishRelease(): void;
+    static get(appObjects: AppObjectRepo): DragLabelDropUC | undefined;
+}
+export declare function makeDragLabelDropUC(appObject: AppObject): DragLabelDropUC;

package/lib/Components/LabelDrop/UseCases/DragLabelDropUC.js

@@ -0,0 +1,171 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDragLabelDropUC = exports.DragLabelDropUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Utilities_1 = require("../../../Utilities");
+const lerpNumber_1 = require("../../../Utilities/lerpNumber");
+const ValueObjects_1 = require("../../../ValueObjects");
+const SceneRayPickUC_1 = require("../../Babylon/UC/SceneRayPickUC");
+const BaseAppState_1 = require("../../BaseApp/Entity/BaseAppState");
+const ChallengeEntity_1 = require("../../Challenge/Entities/ChallengeEntity");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+class DragLabelDropUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(DragLabelDropUC.type, appObjects);
+    }
+}
+exports.DragLabelDropUC = DragLabelDropUC;
+DragLabelDropUC.type = "DragLabelDropUC";
+function makeDragLabelDropUC(appObject) {
+    return new DragLabelDropUCImp(appObject);
+}
+exports.makeDragLabelDropUC = makeDragLabelDropUC;
+class DragLabelDropUCImp extends DragLabelDropUC {
+    constructor(appObject) {
+        super(appObject, DragLabelDropUC.type);
+        this.isDragging = false;
+        this.appObjectID = undefined;
+        this.hitObject = false;
+        this.initialPosition = ValueObjects_1.Vector2.Zero();
+        this.endPosition = ValueObjects_1.Vector2.Zero();
+        this.delta = 10;
+        this.currentPercent = 0;
+        this.correctFadeDurationMS = 200;
+        this.incorrectFadeDurationMS = 300;
+        this.doNothingFadeDurationMS = 500;
+        this.onFinishRelease = () => __awaiter(this, void 0, void 0, function* () {
+            if (!this.repo)
+                return;
+            if (this.interval) {
+                clearInterval(this.interval);
+            }
+            this.currentPercent = 0;
+            this.endPosition = this.repo.screenPosition;
+            if (!this.hitObject) {
+                // no hit
+                this.interval = setInterval(() => {
+                    this.animateLabelDrop(this.doNothingFadeDurationMS);
+                }, this.delta);
+            }
+            else if (this.repo.resultIsCorrect) {
+                // correct
+                yield new Promise((resolve) => setTimeout(resolve, 1000));
+                this.initialPosition = this.endPosition;
+                this.interval = setInterval(() => {
+                    this.animateLabelDrop(this.correctFadeDurationMS);
+                }, this.delta);
+            }
+            else {
+                // incorrect
+                yield new Promise((resolve) => setTimeout(resolve, 1000));
+                this.interval = setInterval(() => {
+                    this.animateLabelDrop(this.incorrectFadeDurationMS);
+                }, this.delta);
+            }
+        });
+        this.animateLabelDrop = (duration) => {
+            if (!this.baseApp)
+                return;
+            if (!this.repo)
+                return;
+            if (!this.interval)
+                return;
+            const difference = 1 / (duration / this.delta);
+            this.currentPercent = this.currentPercent + difference;
+            const newValue = Utilities_1.cubicOut(this.currentPercent);
+            if (newValue >= 1) {
+                this.repo.draggingID = undefined;
+                this.repo.dragAlpha = 0;
+                this.repo.resultIsCorrect = undefined;
+                clearInterval(this.interval);
+                if (this.repo.getRemainingLabelDrops().length === 0) {
+                    this.baseApp.isReviewing = true;
+                }
+            }
+            else {
+                this.repo.dragAlpha = 1 - newValue;
+                const newX = lerpNumber_1.lerpNumber(this.endPosition.x, this.initialPosition.x, newValue);
+                const newY = lerpNumber_1.lerpNumber(this.endPosition.y, this.initialPosition.y, newValue);
+                this.repo.screenPosition = new ValueObjects_1.Vector2(newX, newY);
+            }
+        };
+    }
+    get repo() {
+        return this.getCachedSingleton(LabelDropRepo_1.LabelDropRepo.type);
+    }
+    get challenge() {
+        return this.getCachedSingleton(ChallengeEntity_1.ChallengeEntity.type);
+    }
+    get baseApp() {
+        return this.getCachedSingleton(BaseAppState_1.BaseAppState.type);
+    }
+    initialize(labelDropID, pos) {
+        var _a;
+        if (!this.repo || !this.challenge)
+            return;
+        if (this.challenge.selectedChallenge !== "LABEL_DROP")
+            return;
+        if (((_a = this.baseApp) === null || _a === void 0 ? void 0 : _a.isAuthoring) === true)
+            return;
+        this.repo.draggingID = labelDropID;
+        this.repo.dragMode = LabelDropRepo_1.LabelDropDragMode.SCREEN;
+        this.repo.dragAlpha = 1;
+        this.initialPosition = pos;
+        this.repo.screenPosition = new ValueObjects_1.Vector2(pos.x, pos.y);
+        this.isDragging = true;
+    }
+    setPosition2D(pos) {
+        var _a;
+        if (!this.isDragging)
+            return;
+        if (!this.repo || !this.challenge)
+            return;
+        if (this.challenge.selectedChallenge !== "LABEL_DROP")
+            return;
+        if (((_a = this.baseApp) === null || _a === void 0 ? void 0 : _a.isAuthoring) === true)
+            return;
+        this.repo.screenPosition = new ValueObjects_1.Vector2(pos.x, pos.y);
+    }
+    release(ray) {
+        var _a, _b;
+        if (!this.isDragging)
+            return;
+        this.isDragging = false;
+        if (!this.repo || !this.challenge)
+            return;
+        if (this.challenge.selectedChallenge !== "LABEL_DROP")
+            return;
+        if (((_a = this.baseApp) === null || _a === void 0 ? void 0 : _a.isAuthoring) === true)
+            return;
+        if (!this.repo.draggingID) {
+            this.warn("Trying to release a label drop without an ID");
+            return;
+        }
+        const scenePick = (_b = SceneRayPickUC_1.SceneRayPickUC.get(this.appObjects)) === null || _b === void 0 ? void 0 : _b.sceneRayPick(ray);
+        this.appObjectID = undefined;
+        this.hitObject = true;
+        if (!scenePick ||
+            !scenePick.worldPickPoint ||
+            scenePick.hit === false ||
+            !scenePick.normal ||
+            !scenePick.objectPickMeta) {
+            this.hitObject = false;
+        }
+        else {
+            this.appObjectID = scenePick.objectPickMeta.appObjectID;
+        }
+        if (this.hitObject && this.appObjectID) {
+            this.repo.submitLabelDrop(this.repo.draggingID, this.appObjectID);
+        }
+        this.onFinishRelease();
+    }
+}

package/lib/Components/LabelDrop/UseCases/DragLabelDropWorldUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { ParametricLine } from "../../../ValueObjects";
+export declare abstract class DragLabelDropWorldUC extends AppObjectUC {
+    static readonly type = "DragLabelDropWorldUC";
+    abstract percentOfPickDepth: number;
+    abstract initializeDrag(labelDropID: string, ray: ParametricLine): void;
+    abstract updateDrag(ray: ParametricLine): void;
+    abstract releaseDrag(ray: ParametricLine): void;
+    static get(appObjects: AppObjectRepo): DragLabelDropWorldUC | undefined;
+}
+export declare function makeDragLabelDropWorldUC(appObject: AppObject): DragLabelDropWorldUC;