@vived/app 4.27.0 → 4.28.0

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;

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;