@vived/app 4.27.0 → 4.28.0

package/lib/Components/LabelDrop/Mocks/ValidateLabelDropUc.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeValidateLabelDropMock = exports.ValidateLabelDropMock = void 0;
+const ValidateLabelDrop_1 = require("../UseCases/ValidateLabelDrop");
+class ValidateLabelDropMock extends ValidateLabelDrop_1.ValidateLabelDrop {
+    constructor(appObject) {
+        super(appObject, ValidateLabelDrop_1.ValidateLabelDrop.type);
+        this.validate = jest.fn();
+    }
+}
+exports.ValidateLabelDropMock = ValidateLabelDropMock;
+function makeValidateLabelDropMock(appObjects) {
+    return new ValidateLabelDropMock(appObjects.getOrCreate("ValidateLabelDropMock"));
+}
+exports.makeValidateLabelDropMock = makeValidateLabelDropMock;

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

@@ -0,0 +1,15 @@
+export * from "./DeleteLabelDropUcMock";
+export * from "./EditLabelDropUcMock";
+export * from "./LabelDropAnswerItemDetailsPmMock";
+export * from "./LabelDropDragItemPmMock";
+export * from "./LabelDropEditingIdPmMock";
+export * from "./LabelDropListPmMock";
+export * from "./LabelDropReviewPmMock";
+export * from "./MockCorrectAnimation";
+export * from "./MockDragLabelDropUC";
+export * from "./MockDragLabelDropWorldUC";
+export * from "./MockDropAnimation";
+export * from "./MockIncorrectAnimation";
+export * from "./RemainingLabelDropListPmMock";
+export * from "./ToggleLabelDropTargetUcMock";
+export * from "./ValidateLabelDropUc";

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

@@ -0,0 +1,27 @@
+"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("./DeleteLabelDropUcMock"), exports);
+__exportStar(require("./EditLabelDropUcMock"), exports);
+__exportStar(require("./LabelDropAnswerItemDetailsPmMock"), exports);
+__exportStar(require("./LabelDropDragItemPmMock"), exports);
+__exportStar(require("./LabelDropEditingIdPmMock"), exports);
+__exportStar(require("./LabelDropListPmMock"), exports);
+__exportStar(require("./LabelDropReviewPmMock"), exports);
+__exportStar(require("./MockCorrectAnimation"), exports);
+__exportStar(require("./MockDragLabelDropUC"), exports);
+__exportStar(require("./MockDragLabelDropWorldUC"), exports);
+__exportStar(require("./MockDropAnimation"), exports);
+__exportStar(require("./MockIncorrectAnimation"), exports);
+__exportStar(require("./RemainingLabelDropListPmMock"), exports);
+__exportStar(require("./ToggleLabelDropTargetUcMock"), exports);
+__exportStar(require("./ValidateLabelDropUc"), exports);

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

@@ -0,0 +1,18 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+import { Vector2 } from "../../../ValueObjects";
+import { LabelDropDragMode } from "../Entities/LabelDropRepo";
+export interface LabelDropDragItemVM {
+    id?: string;
+    label: string;
+    show: boolean;
+    mode: LabelDropDragMode;
+    resultIsCorrect?: boolean;
+    alpha: number;
+    screenPosition: Vector2;
+}
+export declare abstract class LabelDropDragItemPM extends AppObjectPM<LabelDropDragItemVM> {
+    static readonly type = "LabelDropDragItemPM";
+    static get(appObjects: AppObjectRepo): LabelDropDragItemPM | undefined;
+}
+export declare function makeLabelDropDragItemPM(appObject: AppObject): LabelDropDragItemPM;
+export declare const defaultLabelDropDragItemVM: LabelDropDragItemVM;

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLabelDropDragItemVM = exports.makeLabelDropDragItemPM = exports.LabelDropDragItemPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+class LabelDropDragItemPM extends AppObject_1.AppObjectPM {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(LabelDropDragItemPM.type, appObjects);
+    }
+}
+exports.LabelDropDragItemPM = LabelDropDragItemPM;
+LabelDropDragItemPM.type = "LabelDropDragItemPM";
+function makeLabelDropDragItemPM(appObject) {
+    return new LabelDropDragItemPMImp(appObject);
+}
+exports.makeLabelDropDragItemPM = makeLabelDropDragItemPM;
+class LabelDropDragItemPMImp extends LabelDropDragItemPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, LabelDropDragItemPM.type);
+        this.handleEntityChange = () => {
+            var _a;
+            if (!this.labelDropRepo)
+                return;
+            if (!this.labelDropRepo.draggingID) {
+                const notDraggingVM = Object.assign({}, exports.defaultLabelDropDragItemVM);
+                notDraggingVM.mode = this.labelDropRepo.dragMode;
+                this.doUpdateView(notDraggingVM);
+                return;
+            }
+            const dragItem = this.labelDropRepo.getForAppObject(this.labelDropRepo.draggingID);
+            const showDragItem = this.labelDropRepo.dragAlpha > 0;
+            const vm = {
+                id: this.labelDropRepo.draggingID,
+                label: (_a = dragItem === null || dragItem === void 0 ? void 0 : dragItem.labelEntity.display) !== null && _a !== void 0 ? _a : "",
+                show: showDragItem,
+                mode: this.labelDropRepo.dragMode,
+                resultIsCorrect: this.labelDropRepo.resultIsCorrect,
+                alpha: this.labelDropRepo.dragAlpha,
+                screenPosition: this.labelDropRepo.screenPosition
+            };
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.labelDropRepo) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.handleEntityChange);
+            (_b = this.labelDropRepo) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        (_a = this.labelDropRepo) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.handleEntityChange);
+        this.appObjects.registerSingleton(this);
+        this.handleEntityChange();
+    }
+    get labelDropRepo() {
+        return this.getCachedSingleton(LabelDropRepo_1.LabelDropRepo.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.id !== b.id)
+            return false;
+        if (a.label !== b.label)
+            return false;
+        if (a.show !== b.show)
+            return false;
+        if (a.mode !== b.mode)
+            return false;
+        if (a.resultIsCorrect !== b.resultIsCorrect)
+            return false;
+        if (a.alpha !== b.alpha)
+            return false;
+        if (!ValueObjects_1.Vector2.Equal(a.screenPosition, b.screenPosition))
+            return false;
+        return true;
+    }
+}
+exports.defaultLabelDropDragItemVM = {
+    id: undefined,
+    label: "",
+    show: false,
+    mode: LabelDropRepo_1.LabelDropDragMode.SCREEN,
+    resultIsCorrect: undefined,
+    alpha: 0,
+    screenPosition: new ValueObjects_1.Vector2(0, 0)
+};

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

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface LabelDropEditingIdVM {
+    editingId: string | undefined;
+    isEditingNewAnswer: boolean;
+}
+export declare abstract class LabelDropEditingIDPM extends AppObjectPM<LabelDropEditingIdVM> {
+    static readonly type = "LabelDropEditingIDPM";
+    static get: (appObjects: AppObjectRepo) => LabelDropEditingIDPM | undefined;
+}
+export declare function makeLabelDropEditingIDPM(appObject: AppObject): LabelDropEditingIDPM;
+export declare const defaultLabelDropEditingIDVM: LabelDropEditingIdVM;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLabelDropEditingIDVM = exports.makeLabelDropEditingIDPM = exports.LabelDropEditingIDPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+class LabelDropEditingIDPM extends AppObject_1.AppObjectPM {
+}
+exports.LabelDropEditingIDPM = LabelDropEditingIDPM;
+LabelDropEditingIDPM.type = "LabelDropEditingIDPM";
+LabelDropEditingIDPM.get = (appObjects) => AppObject_1.getSingletonComponent(LabelDropEditingIDPM.type, appObjects);
+function makeLabelDropEditingIDPM(appObject) {
+    return new LabelDropEditingIDPMImp(appObject);
+}
+exports.makeLabelDropEditingIDPM = makeLabelDropEditingIDPM;
+class LabelDropEditingIDPMImp extends LabelDropEditingIDPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, LabelDropEditingIDPM.type);
+        this.onEntityChange = () => {
+            if (!this.labelDropRepo)
+                return;
+            const vm = {
+                editingId: this.labelDropRepo.editingID,
+                isEditingNewAnswer: this.labelDropRepo.isEditingNewAnswer,
+            };
+            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.editingId !== b.editingId)
+            return false;
+        if (a.isEditingNewAnswer !== b.isEditingNewAnswer)
+            return false;
+        return true;
+    }
+}
+exports.defaultLabelDropEditingIDVM = {
+    editingId: undefined,
+    isEditingNewAnswer: false,
+};

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

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface LabelDropListVM {
+    answerItemIds: string[];
+    challengeValidationMessage: string;
+}
+export declare const defaultLabelDropListVM: LabelDropListVM;
+export declare abstract class LabelDropListPM extends AppObjectPM<LabelDropListVM> {
+    static readonly type = "LabelDropListPM";
+    static get: (appObjects: AppObjectRepo) => LabelDropListPM | undefined;
+}
+export declare function makeLabelDropListPM(appObject: AppObject): LabelDropListPM;

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;