@vived/app 4.27.1 → 4.28.0

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

@@ -0,0 +1,181 @@
+"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.makeDragLabelDropWorldUC = exports.DragLabelDropWorldUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+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");
+const CorrectAnimationUC_1 = require("./CorrectAnimationUC");
+const DropOnNothingAnimationUC_1 = require("./DropOnNothingAnimationUC");
+const IncorrectAnimationUC_1 = require("./IncorrectAnimationUC");
+class DragLabelDropWorldUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(DragLabelDropWorldUC.type, appObjects);
+    }
+}
+exports.DragLabelDropWorldUC = DragLabelDropWorldUC;
+DragLabelDropWorldUC.type = "DragLabelDropWorldUC";
+function makeDragLabelDropWorldUC(appObject) {
+    return new DragLabelDropWorldUCImp(appObject);
+}
+exports.makeDragLabelDropWorldUC = makeDragLabelDropWorldUC;
+class DragLabelDropWorldUCImp extends DragLabelDropWorldUC {
+    constructor(appObject) {
+        super(appObject, DragLabelDropWorldUC.type);
+        this.percentOfPickDepth = 0.95;
+        this.isDragging = false;
+        this.dragStartPosition = ValueObjects_1.Vector3.Zero();
+    }
+    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);
+    }
+    initializeDrag(labelDropID, ray) {
+        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;
+        if (this.currentAnimation) {
+            this.currentAnimation.cancel();
+            this.repo.resultIsCorrect = undefined;
+            this.repo.draggingID = undefined;
+        }
+        const pick = this.doPick(ray);
+        if (!pick)
+            return;
+        this.positionHelper(pick);
+        this.positionDragLabelFromHelper();
+        this.repo.draggingID = labelDropID;
+        this.repo.dragMode = LabelDropRepo_1.LabelDropDragMode.WORLD;
+        this.repo.dragAlpha = 1;
+        this.dragStartPosition = pick;
+        this.isDragging = true;
+    }
+    positionHelper(worldPosition) {
+        if (!this.repo)
+            return;
+        const helper = this.repo.dragHelperTransform;
+        helper.worldPosition = worldPosition;
+        const localZ = helper.localPosition.z * this.percentOfPickDepth;
+        helper.localPosition = new ValueObjects_1.Vector3(0, 0, localZ);
+        helper.localRotation = ValueObjects_1.Quaternion.Identity();
+    }
+    doPick(ray) {
+        const scenePick = SceneRayPickUC_1.sceneRayPick(ray, this.appObjects);
+        if (scenePick && scenePick.worldPickPoint) {
+            return scenePick.worldPickPoint;
+        }
+        const zeroParallaxPlane = ValueObjects_1.ParametricPlane.FromPointNormal(ValueObjects_1.Vector3.Zero(), ValueObjects_1.Vector3.Forward());
+        const zeroParallaxPick = zeroParallaxPlane.intersectLine(ray);
+        return zeroParallaxPick;
+    }
+    positionDragLabelFromHelper() {
+        if (!this.repo)
+            return;
+        this.repo.dragLabelTransform.worldPosition = this.repo.dragHelperTransform.worldPosition;
+        this.repo.dragLabelTransform.worldRotation = this.repo.dragHelperTransform.worldRotation;
+    }
+    updateDrag(ray) {
+        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;
+        const pick = this.doPick(ray);
+        if (!pick)
+            return;
+        this.positionHelper(pick);
+        this.positionDragLabelFromHelper();
+    }
+    releaseDrag(ray) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.baseApp)
+                return;
+            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 pickID = (_b = SceneRayPickUC_1.sceneRayPick(ray, this.appObjects)) === null || _b === void 0 ? void 0 : _b.appObjectID;
+            if (!pickID) {
+                const animationUC = DropOnNothingAnimationUC_1.LabelDropOnNothingAnimationUC.get(this.appObjects);
+                if (!animationUC) {
+                    this.warn("Unable to find LabelDropOnNothingAnimationUC");
+                    return;
+                }
+                this.currentAnimation = animationUC;
+                animationUC.desiredFinalPosition = this.dragStartPosition;
+                const didComplete = yield animationUC.start();
+                if (didComplete)
+                    this.onAnimationComplete();
+                return;
+            }
+            const isCorrect = this.repo.submitLabelDrop(this.repo.draggingID, pickID);
+            if (isCorrect) {
+                const animationUC = CorrectAnimationUC_1.LabelDropCorrectAnimationUC.get(this.appObjects);
+                if (!animationUC) {
+                    this.warn("Unable to find LabelDropCorrectAnimationUC");
+                    return;
+                }
+                this.currentAnimation = animationUC;
+                const didComplete = yield animationUC.start();
+                if (didComplete)
+                    this.onAnimationComplete();
+            }
+            else {
+                const animationUC = IncorrectAnimationUC_1.LabelDropIncorrectAnimationUC.get(this.appObjects);
+                if (!animationUC) {
+                    this.warn("Unable to find LabelDropIncorrectAnimationUC");
+                    return;
+                }
+                this.currentAnimation = animationUC;
+                animationUC.desiredFinalPosition = this.dragStartPosition;
+                const didComplete = yield animationUC.start();
+                if (didComplete)
+                    this.onAnimationComplete();
+            }
+        });
+    }
+    onAnimationComplete() {
+        this.currentAnimation = undefined;
+        if (!this.repo || !this.baseApp)
+            return;
+        this.repo.draggingID = undefined;
+        this.repo.resultIsCorrect = undefined;
+        if (this.repo.getRemainingLabelDrops().length === 0) {
+            this.baseApp.isReviewing = true;
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { Vector3 } from "../../../ValueObjects";
+import { LabelDropAnimationI } from "./LabelDropAnimation";
+export declare abstract class LabelDropOnNothingAnimationUC extends AppObjectUC implements LabelDropAnimationI {
+    static type: string;
+    abstract animationDurationMS: number;
+    abstract getIsAnimating(): boolean;
+    abstract desiredFinalPosition: Vector3;
+    abstract start: () => Promise<boolean>;
+    abstract cancel: () => void;
+    static get(appObject: AppObjectRepo): LabelDropOnNothingAnimationUC | undefined;
+}
+export declare function makeLabelDropOnNothingAnimationUC(appObject: AppObject): LabelDropOnNothingAnimationUC;

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLabelDropOnNothingAnimationUC = exports.LabelDropOnNothingAnimationUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Utilities_1 = require("../../../Utilities");
+const ValueObjects_1 = require("../../../ValueObjects");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+class LabelDropOnNothingAnimationUC extends AppObject_1.AppObjectUC {
+    static get(appObject) {
+        return AppObject_1.getSingletonComponent(LabelDropOnNothingAnimationUC.type, appObject);
+    }
+}
+exports.LabelDropOnNothingAnimationUC = LabelDropOnNothingAnimationUC;
+LabelDropOnNothingAnimationUC.type = "LabelDropOnNothingAnimationUC";
+function makeLabelDropOnNothingAnimationUC(appObject) {
+    return new LabelDropOnNothingAnimationUCImp(appObject);
+}
+exports.makeLabelDropOnNothingAnimationUC = makeLabelDropOnNothingAnimationUC;
+class LabelDropOnNothingAnimationUCImp extends LabelDropOnNothingAnimationUC {
+    constructor(appObject) {
+        super(appObject, LabelDropOnNothingAnimationUC.type);
+        this.animationDurationMS = 500;
+        this.desiredFinalPosition = ValueObjects_1.Vector3.Zero();
+        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) => {
+                var _a, _b;
+                const startTime = Date.now();
+                const endTime = startTime + this.animationDurationMS;
+                this._isAnimating = true;
+                const startPosition = (_b = (_a = this.labelDropEntity) === null || _a === void 0 ? void 0 : _a.dragLabelTransform.worldPosition) !== null && _b !== void 0 ? _b : ValueObjects_1.Vector3.Zero();
+                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._isAnimating = false;
+                        this.labelDropEntity.dragAlpha = 0;
+                        this.labelDropEntity.dragLabelTransform.worldPosition =
+                            this.desiredFinalPosition;
+                        clearInterval(interval);
+                        resolve(true);
+                    }
+                    else {
+                        const animationPercent = (currentTime - startTime) / this.animationDurationMS;
+                        const acceleratorValue = 1.5;
+                        let alpha = 1 - acceleratorValue * animationPercent;
+                        if (alpha < 0)
+                            alpha = 0;
+                        this.labelDropEntity.dragAlpha = alpha;
+                        const easedPercent = Utilities_1.cubicOut(animationPercent);
+                        const lerpedPos = ValueObjects_1.Vector3.Lerp(startPosition, this.desiredFinalPosition, easedPercent);
+                        this.labelDropEntity.dragLabelTransform.worldPosition = lerpedPos;
+                    }
+                }, 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/EditLabelDropUC.d.ts

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class EditLabelDropUC extends AppObjectUC {
+    static readonly type = "EditLabelDropUC";
+    abstract start(labelDropID?: string): void;
+    abstract discard(): void;
+    abstract finish(): void;
+    static get: (appObjects: AppObjectRepo) => EditLabelDropUC | undefined;
+}
+export declare function makeEditLabelDropUC(appObject: AppObject): EditLabelDropUC;

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEditLabelDropUC = exports.EditLabelDropUC = 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");
+const ShowConfirmUC_1 = require("../../Dispatcher/UC/ShowConfirmUC");
+class EditLabelDropUC extends AppObject_1.AppObjectUC {
+}
+exports.EditLabelDropUC = EditLabelDropUC;
+EditLabelDropUC.type = "EditLabelDropUC";
+EditLabelDropUC.get = (appObjects) => AppObject_1.getSingletonComponent(EditLabelDropUC.type, appObjects);
+function makeEditLabelDropUC(appObject) {
+    return new EditLabelDropUCImp(appObject);
+}
+exports.makeEditLabelDropUC = makeEditLabelDropUC;
+class EditLabelDropUCImp extends EditLabelDropUC {
+    constructor(appObject) {
+        super(appObject, EditLabelDropUC.type);
+        this.message = "Are you sure you want to discard changes made to this label drop answer?";
+        this.title = "Discard Changes";
+        this.confirmButton = "Discard";
+        this.cancelButton = "Cancel";
+        this.start = (labelDropID) => {
+            if (!this.labelDropRepo)
+                return;
+            this.editingItem = labelDropID
+                ? this.labelDropRepo.getForAppObject(labelDropID)
+                : this.labelDropRepo.makeLabelDropItem();
+            if (!this.editingItem) {
+                this.warn("No label drop found for ID: " + labelDropID);
+                this.clearEditLabelDrop();
+                return;
+            }
+            this.initialData = this.editingItem.data;
+            this.labelDropRepo.editingID = this.editingItem.id;
+            this.labelDropRepo.isEditingNewAnswer = labelDropID ? false : true;
+        };
+        this.discard = () => {
+            if (!this.isEditChanged()) {
+                this.onConfirmDiscardEdits();
+                return;
+            }
+            const showConfirm = ShowConfirmUC_1.ShowConfirmUC.get(this.appObjects);
+            if (!showConfirm) {
+                this.warn("Could not find ShowConfirmUC");
+                return;
+            }
+            const dto = {
+                cancelButtonLabel: this.cancelButton,
+                confirmButtonLabel: this.confirmButton,
+                message: this.message,
+                title: this.title,
+                confirmCallback: this.onConfirmDiscardEdits,
+                cancelCallback: () => { }
+            };
+            showConfirm.showConfirm(dto);
+        };
+        this.isEditChanged = () => {
+            var _a;
+            if (!this.editingItem || !this.labelDropRepo || !this.initialData)
+                return false;
+            if ((_a = this.labelDropRepo) === null || _a === void 0 ? void 0 : _a.isEditingNewAnswer)
+                return true;
+            const currentData = this.editingItem.data;
+            if (currentData.label !== this.initialData.label)
+                return true;
+            if (currentData.correctAppObjectIDs.length !==
+                this.initialData.correctAppObjectIDs.length)
+                return true;
+            for (const correctObjectId of currentData.correctAppObjectIDs) {
+                if (!this.initialData.correctAppObjectIDs.includes(correctObjectId))
+                    return true;
+            }
+            return false;
+        };
+        this.onConfirmDiscardEdits = () => {
+            if (!this.editingItem || !this.labelDropRepo || !this.initialData)
+                return;
+            if (this.labelDropRepo.isEditingNewAnswer) {
+                this.labelDropRepo.deleteItem(this.editingItem.id);
+            }
+            else {
+                this.editingItem.data = this.initialData;
+            }
+            this.clearEditLabelDrop();
+        };
+        this.finish = () => {
+            var _a, _b;
+            if (!this.isEditChanged()) {
+                this.clearEditLabelDrop();
+                return;
+            }
+            const repo = this.labelDropRepo;
+            const initialData = this.initialData;
+            const item = this.editingItem;
+            const dispatchStateChange = this.dispatchStateChange;
+            if (!repo || !initialData || !item || !dispatchStateChange)
+                return;
+            const finalData = item.data;
+            if (repo.isEditingNewAnswer) {
+                (_a = this.undo) === null || _a === void 0 ? void 0 : _a.submitAction({
+                    undoAction: () => {
+                        repo.deleteItem(item.id);
+                        dispatchStateChange();
+                    },
+                    redoAction: () => {
+                        repo.makeLabelDropItem(item.id).data = finalData;
+                        dispatchStateChange();
+                    }
+                });
+            }
+            else {
+                (_b = this.undo) === null || _b === void 0 ? void 0 : _b.submitAction({
+                    undoAction: () => {
+                        item.data = initialData;
+                        dispatchStateChange();
+                    },
+                    redoAction: () => {
+                        item.data = finalData;
+                        dispatchStateChange();
+                    }
+                });
+            }
+            this.clearEditLabelDrop();
+            dispatchStateChange();
+        };
+        this.clearEditLabelDrop = () => {
+            if (!this.labelDropRepo)
+                return;
+            this.initialData = undefined;
+            this.editingItem = undefined;
+            this.labelDropRepo.editingID = undefined;
+            this.labelDropRepo.isEditingNewAnswer = false;
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get labelDropRepo() {
+        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;
+    }
+}

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

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

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLabelDropIncorrectAnimationUC = exports.LabelDropIncorrectAnimationUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Utilities_1 = require("../../../Utilities");
+const ValueObjects_1 = require("../../../ValueObjects");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+class LabelDropIncorrectAnimationUC extends AppObject_1.AppObjectUC {
+    static get(appObject) {
+        return AppObject_1.getSingletonComponent(LabelDropIncorrectAnimationUC.type, appObject);
+    }
+}
+exports.LabelDropIncorrectAnimationUC = LabelDropIncorrectAnimationUC;
+LabelDropIncorrectAnimationUC.type = "LabelDropIncorrectAnimationUC";
+function makeLabelDropIncorrectAnimationUC(appObject) {
+    return new LabelDropIncorrectAnimationUCImp(appObject);
+}
+exports.makeLabelDropIncorrectAnimationUC = makeLabelDropIncorrectAnimationUC;
+class LabelDropIncorrectAnimationUCImp extends LabelDropIncorrectAnimationUC {
+    constructor(appObject) {
+        super(appObject, LabelDropIncorrectAnimationUC.type);
+        this.feedbackDurationMS = 1000;
+        this.fadeDurationMS = 300;
+        this.desiredFinalPosition = ValueObjects_1.Vector3.Zero();
+        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, reject) => {
+                var _a, _b;
+                const startTime = Date.now();
+                const fadeStartTime = startTime + this.feedbackDurationMS;
+                const endTime = startTime + this.fadeDurationMS + this.feedbackDurationMS;
+                this._isAnimating = true;
+                const startPosition = (_b = (_a = this.labelDropEntity) === null || _a === void 0 ? void 0 : _a.dragLabelTransform.worldPosition) !== null && _b !== void 0 ? _b : ValueObjects_1.Vector3.Zero();
+                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;
+                        this.labelDropEntity.dragLabelTransform.worldPosition =
+                            this.desiredFinalPosition;
+                        clearInterval(interval);
+                        resolve(true);
+                    }
+                    else if (currentTime >= fadeStartTime) {
+                        const animationPercent = (currentTime - fadeStartTime) / this.fadeDurationMS;
+                        const acceleratorValue = 1.5;
+                        let alpha = 1 - acceleratorValue * animationPercent;
+                        if (alpha < 0)
+                            alpha = 0;
+                        this.labelDropEntity.dragAlpha = alpha;
+                        const easedPercent = Utilities_1.cubicOut(animationPercent);
+                        const lerpedPos = ValueObjects_1.Vector3.Lerp(startPosition, this.desiredFinalPosition, easedPercent);
+                        this.labelDropEntity.dragLabelTransform.worldPosition = lerpedPos;
+                    }
+                }, 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/InitializeLabelDropLabelHook.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+export declare class InitializeLabelDropLabelHook extends AppObjectUC {
+    static type: string;
+    private get item();
+    onChangeLabelDropEntity: () => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitializeLabelDropLabelHook = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../Label/Entities");
+const LabelDropItemEntity_1 = require("../Entities/LabelDropItemEntity");
+class InitializeLabelDropLabelHook extends AppObject_1.AppObjectUC {
+    constructor(appObject) {
+        var _a;
+        super(appObject, InitializeLabelDropLabelHook.type);
+        this.onChangeLabelDropEntity = () => {
+            if (!this.item)
+                return;
+            if (this.item.label || this.item.targetIds.length > 1) {
+                this.item.removeChangeObserver(this.onChangeLabelDropEntity);
+                return;
+            }
+            if (this.item.targetIds.length === 0) {
+                return;
+            }
+            const firstTarget = this.item.targetIds[0];
+            const label = Entities_1.LabelEntity.getByID(firstTarget, this.appObjects);
+            if (!label) {
+                return;
+            }
+            this.item.removeChangeObserver(this.onChangeLabelDropEntity);
+            this.item.label = label.display;
+        };
+        (_a = this.item) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onChangeLabelDropEntity);
+    }
+    get item() {
+        return this.getCachedLocalComponent(LabelDropItemEntity_1.LabelDropItemEntity.type);
+    }
+}
+exports.InitializeLabelDropLabelHook = InitializeLabelDropLabelHook;
+InitializeLabelDropLabelHook.type = "InitializeLabelDropLabelHook";

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

@@ -0,0 +1,5 @@
+export interface LabelDropAnimationI {
+    getIsAnimating(): boolean;
+    start: () => Promise<boolean>;
+    cancel: () => void;
+}

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

@@ -0,0 +1,21 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { SerializedSystem } from "../../StateMachine/Entities/StateMachineEntity";
+export declare class SerializeLabelDrop extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeLabelDrop";
+    name: string;
+    seriliziationVersion: number;
+    private get labelDrop();
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    private applyStateV1;
+    applyDefaultState(): void;
+    constructor(appObject: AppObject);
+}
+export interface SerializedLabelDropV1 {
+    labelDrops: SerializedLabelDropItemV1[];
+}
+export interface SerializedLabelDropItemV1 {
+    id: string;
+    label: string;
+    correctAppObjectIDs: string[];
+}