@vived/app 4.27.0 → 4.28.0

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/LabelDropAnimation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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[];
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeLabelDrop = void 0;
+const AppObject_1 = require("../../../AppObject");
+const StateMachineEntity_1 = require("../../StateMachine/Entities/StateMachineEntity");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+class SerializeLabelDrop extends AppObject_1.AppObjectUC {
+    constructor(appObject) {
+        super(appObject, SerializeLabelDrop.type);
+        this.name = "label-drop";
+        this.seriliziationVersion = 1;
+        const stateMachine = StateMachineEntity_1.StateMachineEntity.get(appObject.appObjectRepo);
+        if (stateMachine) {
+            stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            this.error("Unable to find StateMachineEntity");
+        }
+    }
+    get labelDrop() {
+        return this.getCachedSingleton(LabelDropRepo_1.LabelDropRepo.type);
+    }
+    getSystemState() {
+        if (!this.labelDrop)
+            return {};
+        const labelDrops = this.labelDrop
+            .getAll()
+            .map((dropItem) => {
+            return {
+                id: dropItem.id,
+                label: dropItem.labelEntity.custom,
+                correctAppObjectIDs: dropItem.targetIds,
+            };
+        });
+        const state = {
+            labelDrops,
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (version === 1) {
+            this.applyStateV1(state);
+        }
+        else {
+            this.applyDefaultState();
+        }
+    }
+    applyStateV1(state) {
+        if (!this.labelDrop)
+            return;
+        if (state.labelDrops === undefined) {
+            this.applyDefaultState();
+            return;
+        }
+        this.labelDrop.deleteAllItems();
+        state.labelDrops.forEach((dropItem) => {
+            const item = this.labelDrop.makeLabelDropItem(dropItem.id);
+            item.labelEntity.custom = dropItem.label;
+            item.targetIds = dropItem.correctAppObjectIDs;
+        });
+    }
+    applyDefaultState() {
+        if (!this.labelDrop)
+            return;
+        this.labelDrop.deleteAllItems();
+    }
+}
+exports.SerializeLabelDrop = SerializeLabelDrop;
+SerializeLabelDrop.type = "SerializeLabelDrop";

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

@@ -0,0 +1,10 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { ParametricLine, Vector2 } from "../../../ValueObjects";
+export declare abstract class ToggleLabelDropTargetUC extends AppObjectUC {
+    static readonly type = "ToggleLabelDropTargetUC";
+    abstract tryToggleFromRay(ray: ParametricLine): void;
+    abstract tryToggleFromPixel(pixel: Vector2): void;
+    abstract toggleByID(id: string): void;
+    static get(appObjects: AppObjectRepo): ToggleLabelDropTargetUC | undefined;
+}
+export declare function makeToggleLabelDropTargetUC(appObject: AppObject): ToggleLabelDropTargetUC;

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeToggleLabelDropTargetUC = exports.ToggleLabelDropTargetUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const UC_1 = require("../../Babylon/UC");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+class ToggleLabelDropTargetUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(ToggleLabelDropTargetUC.type, appObjects);
+    }
+}
+exports.ToggleLabelDropTargetUC = ToggleLabelDropTargetUC;
+ToggleLabelDropTargetUC.type = "ToggleLabelDropTargetUC";
+function makeToggleLabelDropTargetUC(appObject) {
+    return new ToggleLabelDropTargetUCImp(appObject);
+}
+exports.makeToggleLabelDropTargetUC = makeToggleLabelDropTargetUC;
+class ToggleLabelDropTargetUCImp extends ToggleLabelDropTargetUC {
+    get repo() {
+        return this.getCachedSingleton(LabelDropRepo_1.LabelDropRepo.type);
+    }
+    get sceneRayPick() {
+        var _a;
+        return (_a = this.getCachedSingleton(UC_1.SceneRayPickUC.type)) === null || _a === void 0 ? void 0 : _a.sceneRayPick;
+    }
+    get pixelToRay() {
+        var _a;
+        return (_a = this.getCachedSingleton(UC_1.PixelToSceneRayUC.type)) === null || _a === void 0 ? void 0 : _a.pixelToSceneRay;
+    }
+    tryToggleFromPixel(pixel) {
+        if (!this.pixelToRay)
+            return;
+        const ray = this.pixelToRay(pixel);
+        if (!ray)
+            return;
+        this.tryToggleFromRay(ray);
+    }
+    toggleByID(id) {
+        if (!this.repo)
+            return;
+        if (!this.repo.editingID)
+            return;
+        const editingItem = this.repo.getForAppObject(this.repo.editingID);
+        if (!editingItem)
+            return;
+        if (editingItem.targetIds.includes(id)) {
+            editingItem.removeTargetID(id);
+        }
+        else {
+            editingItem.addTargetID(id);
+        }
+    }
+    tryToggleFromRay(ray) {
+        var _a;
+        if (!this.sceneRayPick)
+            return;
+        const pickedID = (_a = this.sceneRayPick(ray)) === null || _a === void 0 ? void 0 : _a.appObjectID;
+        if (!pickedID)
+            return;
+        this.toggleByID(pickedID);
+    }
+    constructor(appObject) {
+        super(appObject, ToggleLabelDropTargetUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class ValidateLabelDrop extends AppObjectUC {
+    static type: string;
+    abstract validate(): string | null;
+    LABEL_DROP_ANSWER_REQUIRED: string;
+    LABEL_DROP_STILL_EDITING: string;
+    static get(appObjects: AppObjectRepo): ValidateLabelDrop | undefined;
+}
+export declare function makeValidateLabelDrop(appObject: AppObject): ValidateLabelDrop;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeValidateLabelDrop = exports.ValidateLabelDrop = void 0;
+const AppObject_1 = require("../../../AppObject");
+const BaseAppState_1 = require("../../BaseApp/Entity/BaseAppState");
+const LabelDropRepo_1 = require("../Entities/LabelDropRepo");
+class ValidateLabelDrop extends AppObject_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.LABEL_DROP_ANSWER_REQUIRED = "At least one label drop answer item is required";
+        this.LABEL_DROP_STILL_EDITING = "Cannot save while still editing a label drop answer";
+    }
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(ValidateLabelDrop.type, appObjects);
+    }
+}
+exports.ValidateLabelDrop = ValidateLabelDrop;
+ValidateLabelDrop.type = "ValidateLabelDrop";
+function makeValidateLabelDrop(appObject) {
+    return new ValidateLabelDropImp(appObject);
+}
+exports.makeValidateLabelDrop = makeValidateLabelDrop;
+class ValidateLabelDropImp extends ValidateLabelDrop {
+    constructor(appObject) {
+        super(appObject, ValidateLabelDrop.type);
+        this.validate = () => {
+            if (!this.labelDrop) {
+                this.error("Unable to find Label Drop Repo");
+                return null;
+            }
+            if (this.labelDrop.getAll().length === 0) {
+                return this.LABEL_DROP_ANSWER_REQUIRED;
+            }
+            if (this.labelDrop.editingID) {
+                return this.LABEL_DROP_STILL_EDITING;
+            }
+            let itemValidation;
+            this.labelDrop.getAll().forEach((item) => {
+                if (item.labelEntity.customLabelValidationMessage) {
+                    itemValidation = item.labelEntity.customLabelValidationMessage;
+                }
+                if (item.targetValidationMessage) {
+                    itemValidation = item.targetValidationMessage;
+                }
+            });
+            if (itemValidation) {
+                return itemValidation;
+            }
+            return null;
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get baseApp() {
+        return this.getCachedSingleton(BaseAppState_1.BaseAppState.type);
+    }
+    get labelDrop() {
+        return this.getCachedSingleton(LabelDropRepo_1.LabelDropRepo.type);
+    }
+}

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

@@ -0,0 +1,14 @@
+export * from "./CorrectAnimationUC";
+export * from "./DeleteAllLabelDropUC";
+export * from "./DeleteLabelDropUC";
+export * from "./DragLabelDropUC";
+export * from "./DragLabelDropWorldUC";
+export * from "./DropOnNothingAnimationUC";
+export * from "./EditLabelDropUC";
+export * from "./IncorrectAnimationUC";
+export * from "./InitializeLabelDropLabelHook";
+export * from "./LabelDropAnimation";
+export * from "./SerializeLabelDrop";
+export * from "./ToggleLabelDropTargetUC";
+export * from "./ValidateLabelDrop";
+export * from "./labelDropLabelValidator";

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

@@ -0,0 +1,26 @@
+"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("./CorrectAnimationUC"), exports);
+__exportStar(require("./DeleteAllLabelDropUC"), exports);
+__exportStar(require("./DeleteLabelDropUC"), exports);
+__exportStar(require("./DragLabelDropUC"), exports);
+__exportStar(require("./DragLabelDropWorldUC"), exports);
+__exportStar(require("./DropOnNothingAnimationUC"), exports);
+__exportStar(require("./EditLabelDropUC"), exports);
+__exportStar(require("./IncorrectAnimationUC"), exports);
+__exportStar(require("./InitializeLabelDropLabelHook"), exports);
+__exportStar(require("./LabelDropAnimation"), exports);
+__exportStar(require("./SerializeLabelDrop"), exports);
+__exportStar(require("./ToggleLabelDropTargetUC"), exports);
+__exportStar(require("./ValidateLabelDrop"), exports);
+__exportStar(require("./labelDropLabelValidator"), exports);

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

@@ -0,0 +1 @@
+export declare function labelDropLabelValidator(val: string): string | null;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.labelDropLabelValidator = void 0;
+const LabelDropItemEntity_1 = require("../Entities/LabelDropItemEntity");
+function labelDropLabelValidator(val) {
+    if (!val) {
+        return LabelDropItemEntity_1.LabelDropItemEntity.LABEL_DROP_EMPTY;
+    }
+    else if (val.length > 40) {
+        return LabelDropItemEntity_1.LabelDropItemEntity.LABEL_DROP_TOO_LONG;
+    }
+    else {
+        return null;
+    }
+}
+exports.labelDropLabelValidator = labelDropLabelValidator;

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

@@ -0,0 +1,6 @@
+export * from "./Adapters";
+export * from "./Controller";
+export * from "./Entities";
+export * from "./Mocks";
+export * from "./PM";
+export * from "./UseCases";

package/lib/Components/LabelDrop/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("./Adapters"), exports);
+__exportStar(require("./Controller"), exports);
+__exportStar(require("./Entities"), exports);
+__exportStar(require("./Mocks"), exports);
+__exportStar(require("./PM"), exports);
+__exportStar(require("./UseCases"), exports);

package/lib/Components/Question/Entities/QuestionEntity.d.ts

@@ -2,10 +2,16 @@ import { AppObject } from "../../../AppObject/AppObject";
 import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
 import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
 import { QuestionAnswerEntity } from "./QuestionAnswerEntity";
+import { Challenge } from "../../Challenge/Entities";
 export declare const VALIDATION_NO_CORRECT = "At least one answer must be correct.";
 export declare const VALIDATION_NOT_ENOUGH_ANSWERS = "Question must have at least two answers";
-export declare abstract class QuestionEntity extends AppObjectEntity {
+export declare abstract class QuestionEntity extends AppObjectEntity implements Challenge {
     static readonly type = "QuestionEntity";
+    readonly challengeID = "QUESTION";
+    name: string;
+    helpHeading: string;
+    consumerHelpText: string;
+    authorHelpText: string;
     abstract get gotItRight(): boolean;
     abstract get reviewFeedback(): string;
     abstract addAnswer: (answer: QuestionAnswerEntity) => void;