@vived/app 4.27.1 → 4.28.1

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLabelDropListPM = exports.LabelDropListPM = exports.defaultLabelDropListVM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+exports.defaultLabelDropListVM = {
+    answerItemIds: [],
+    challengeValidationMessage: "",
+};
+class LabelDropListPM extends AppObject_1.AppObjectPM {
+}
+exports.LabelDropListPM = LabelDropListPM;
+LabelDropListPM.type = "LabelDropListPM";
+LabelDropListPM.get = (appObjects) => AppObject_1.getSingletonComponent(LabelDropListPM.type, appObjects);
+function makeLabelDropListPM(appObject) {
+    return new LabelDropListPMImp(appObject);
+}
+exports.makeLabelDropListPM = makeLabelDropListPM;
+class LabelDropListPMImp extends LabelDropListPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, LabelDropListPM.type);
+        this.onEntityChange = () => {
+            var _a;
+            if (!this.labelDropRepo)
+                return;
+            const answerItemIds = this.labelDropRepo
+                .getAll()
+                .map((item) => item.id);
+            const vm = {
+                answerItemIds,
+                challengeValidationMessage: (_a = this.labelDropRepo.validationMessage) !== null && _a !== void 0 ? _a : "",
+            };
+            this.doUpdateView(vm);
+        };
+        (_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.answerItemIds.length !== b.answerItemIds.length)
+            return false;
+        if (a.challengeValidationMessage !== b.challengeValidationMessage)
+            return false;
+        let itemListIsEqual = true;
+        for (let i = 0; i < a.answerItemIds.length; i++) {
+            if (a.answerItemIds[i] !== b.answerItemIds[i]) {
+                itemListIsEqual = false;
+            }
+        }
+        return itemListIsEqual;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface LabelDropItemReviewVM {
+    id: string;
+    label: string;
+    tries: number;
+}
+export declare abstract class LabelDropReviewPM extends AppObjectPM<LabelDropItemReviewVM[]> {
+    static readonly type = "LabelDropReviewPM";
+    static get: (appObjects: AppObjectRepo) => LabelDropReviewPM | undefined;
+}
+export declare function makeLabelDropReviewPM(appObject: AppObject): LabelDropReviewPM;

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLabelDropReviewPM = exports.LabelDropReviewPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+class LabelDropReviewPM extends AppObject_1.AppObjectPM {
+}
+exports.LabelDropReviewPM = LabelDropReviewPM;
+LabelDropReviewPM.type = "LabelDropReviewPM";
+LabelDropReviewPM.get = (appObjects) => AppObject_1.getSingletonComponent(LabelDropReviewPM.type, appObjects);
+function makeLabelDropReviewPM(appObject) {
+    return new LabelDropReviewPMImp(appObject);
+}
+exports.makeLabelDropReviewPM = makeLabelDropReviewPM;
+class LabelDropReviewPMImp extends LabelDropReviewPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, LabelDropReviewPM.type);
+        this.onEntityChange = () => {
+            if (!this.labelDropRepo)
+                return;
+            const labelDropReviewVM = this.labelDropRepo
+                .getAll()
+                .map((item) => {
+                return {
+                    id: item.id,
+                    label: item.labelEntity.display,
+                    tries: item.tries
+                };
+            });
+            this.doUpdateView(labelDropReviewVM);
+        };
+        (_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;
+            }
+            else if (a[i].tries !== b[i].tries) {
+                vmsEqual = false;
+            }
+        }
+        return vmsEqual;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface LabelDropTargetsVM {
+    targetIds: string[];
+    targetValidationMessage: string | undefined;
+}
+export declare const defaultLabelDropTargetsVM: LabelDropTargetsVM;
+export declare abstract class LabelDropTargetsPM extends AppObjectPM<LabelDropTargetsVM> {
+    static readonly type = "LabelDropTargetsPM";
+    static get(id: string, appObjects: AppObjectRepo): LabelDropTargetsPM | undefined;
+}
+export declare function makeLabelDropTargetsPM(appObject: AppObject): LabelDropTargetsPM;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLabelDropTargetsPM = exports.LabelDropTargetsPM = exports.defaultLabelDropTargetsVM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const LabelDropItemEntity_1 = require("../Entities/LabelDropItemEntity");
+exports.defaultLabelDropTargetsVM = {
+    targetIds: [],
+    targetValidationMessage: undefined
+};
+class LabelDropTargetsPM extends AppObject_1.AppObjectPM {
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects
+            .get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(LabelDropTargetsPM.type);
+    }
+}
+exports.LabelDropTargetsPM = LabelDropTargetsPM;
+LabelDropTargetsPM.type = "LabelDropTargetsPM";
+function makeLabelDropTargetsPM(appObject) {
+    return new LabelDropTargetsPMImp(appObject);
+}
+exports.makeLabelDropTargetsPM = makeLabelDropTargetsPM;
+class LabelDropTargetsPMImp extends LabelDropTargetsPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, LabelDropTargetsPM.type);
+        this.onEntityChange = () => {
+            if (!this.entity)
+                return;
+            const vm = {
+                targetIds: [...this.entity.targetIds],
+                targetValidationMessage: this.entity.targetValidationMessage
+            };
+            this.doUpdateView(vm);
+        };
+        (_a = this.entity) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+    }
+    get entity() {
+        return this.getCachedLocalComponent(LabelDropItemEntity_1.LabelDropItemEntity.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.targetValidationMessage !== b.targetValidationMessage)
+            return false;
+        if (a.targetIds.length !== b.targetIds.length)
+            return false;
+        let targetsAreEqual = true;
+        for (let i = 0; i < a.targetIds.length; i++) {
+            if (a.targetIds[i] !== b.targetIds[i]) {
+                targetsAreEqual = false;
+            }
+        }
+        return targetsAreEqual;
+    }
+}

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

@@ -0,0 +1,10 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface RemainingLabelDropVM {
+    id: string;
+    label: string;
+}
+export declare abstract class RemainingLabelDropListPM extends AppObjectPM<RemainingLabelDropVM[]> {
+    static readonly type = "RemainingLabelDropListPM";
+    static get: (appObjects: AppObjectRepo) => RemainingLabelDropListPM | undefined;
+}
+export declare function makeRemainingLabelDropListPM(appObject: AppObject): RemainingLabelDropListPM;

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;