@vived/app 4.27.1 → 4.28.1

package/lib/Components/LabelDrop/Controller/initializeDragLabelDropAnswerItem.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeDragLabelDropAnswerItem = void 0;
+const ValueObjects_1 = require("../../../ValueObjects");
+const DragLabelDropUC_1 = require("../UseCases/DragLabelDropUC");
+function initializeDragLabelDropAnswerItem(labelDropID, screenX, screenY, appObjects) {
+    const uc = DragLabelDropUC_1.DragLabelDropUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("initializeDragLabelDropAnswerItem", "Unable to find DragLabelDropUC");
+        return;
+    }
+    uc.initialize(labelDropID, new ValueObjects_1.Vector2(screenX, screenY));
+}
+exports.initializeDragLabelDropAnswerItem = initializeDragLabelDropAnswerItem;

package/lib/Components/LabelDrop/Controller/initializeDragLabelDropAnswerItemWorld.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject";
+export declare function initializeDragLabelDropAnswerItemWorld(labelDropID: string, appObjects: AppObjectRepo): void;

package/lib/Components/LabelDrop/Controller/initializeDragLabelDropAnswerItemWorld.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeDragLabelDropAnswerItemWorld = void 0;
+const StylusEntity_1 = require("../../Stylus/Entity/StylusEntity");
+const DragLabelDropWorldUC_1 = require("../UseCases/DragLabelDropWorldUC");
+function initializeDragLabelDropAnswerItemWorld(labelDropID, appObjects) {
+    const uc = DragLabelDropWorldUC_1.DragLabelDropWorldUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("initializeDragLabelDropAnswerItem", "Unable to find DragLabelDropWorldUC");
+        return;
+    }
+    const stylus = StylusEntity_1.StylusEntity.get(appObjects);
+    if (!stylus) {
+        appObjects.submitError("initializeDragLabelDropAnswerItemWorld", "Unable to find StylusEntity");
+        return;
+    }
+    uc.initializeDrag(labelDropID, stylus.pickRay);
+}
+exports.initializeDragLabelDropAnswerItemWorld = initializeDragLabelDropAnswerItemWorld;

package/lib/Components/LabelDrop/Controller/releaseLabelDropAnswerItemScreen.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject";
+export declare function releaseLabelDropAnswerItemScreen(screenX: number, screenY: number, appObjects: AppObjectRepo): void;

package/lib/Components/LabelDrop/Controller/releaseLabelDropAnswerItemScreen.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseLabelDropAnswerItemScreen = void 0;
+const ValueObjects_1 = require("../../../ValueObjects");
+const PixelToSceneRayUC_1 = require("../../Babylon/UC/PixelToSceneRayUC");
+const FramedScreenEntity_1 = require("../../FramedScreen/Entities/FramedScreenEntity");
+const DragLabelDropUC_1 = require("../UseCases/DragLabelDropUC");
+function releaseLabelDropAnswerItemScreen(screenX, screenY, appObjects) {
+    var _a;
+    const uc = DragLabelDropUC_1.DragLabelDropUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("releaseLabelDropAnswerItem", "Unable to find DragLabelDropUC");
+        return;
+    }
+    let pickOffsetX = 0;
+    let pickOffsetY = 0;
+    const framedScreen = appObjects.getSingleton(FramedScreenEntity_1.FramedScreenEntity.type);
+    const renderCanvas = framedScreen === null || framedScreen === void 0 ? void 0 : framedScreen.getContainerByID("Render_Canvas");
+    if (renderCanvas) {
+        pickOffsetX += renderCanvas.position.x;
+        pickOffsetY += renderCanvas.position.y;
+    }
+    const ray = (_a = PixelToSceneRayUC_1.PixelToSceneRayUC.get(appObjects)) === null || _a === void 0 ? void 0 : _a.pixelToSceneRay(new ValueObjects_1.Vector2(screenX - pickOffsetX, screenY - pickOffsetY));
+    if (ray) {
+        uc.release(ray);
+    }
+}
+exports.releaseLabelDropAnswerItemScreen = releaseLabelDropAnswerItemScreen;

package/lib/Components/LabelDrop/Controller/releaseLabelDropAnswerItemWorld.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject";
+export declare function releaseLabelDropAnswerItemWorld(appObjects: AppObjectRepo): void;

package/lib/Components/LabelDrop/Controller/releaseLabelDropAnswerItemWorld.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseLabelDropAnswerItemWorld = void 0;
+const StylusEntity_1 = require("../../Stylus/Entity/StylusEntity");
+const DragLabelDropWorldUC_1 = require("../UseCases/DragLabelDropWorldUC");
+function releaseLabelDropAnswerItemWorld(appObjects) {
+    const uc = DragLabelDropWorldUC_1.DragLabelDropWorldUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitError("releaseLabelDropAnswerItem", "Unable to find DragLabelDropWorldUC");
+        return;
+    }
+    const stylus = StylusEntity_1.StylusEntity.get(appObjects);
+    if (!stylus) {
+        appObjects.submitError("releaseLabelDropAnswerItem", "Unable to find StylusEntity");
+        return;
+    }
+    uc.releaseDrag(stylus.pickRay);
+}
+exports.releaseLabelDropAnswerItemWorld = releaseLabelDropAnswerItemWorld;

package/lib/Components/LabelDrop/Controller/saveEditLabelDropAnswer.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject";
+export declare function saveEditLabelDropAnswer(appObjects: AppObjectRepo): void;

package/lib/Components/LabelDrop/Controller/saveEditLabelDropAnswer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveEditLabelDropAnswer = void 0;
+const EditLabelDropUC_1 = require("../UseCases/EditLabelDropUC");
+function saveEditLabelDropAnswer(appObjects) {
+    const editUC = EditLabelDropUC_1.EditLabelDropUC.get(appObjects);
+    if (!editUC) {
+        appObjects.submitWarning("saveEditLabelDropAnswer", "Unable to find EditLabelDropUC");
+        return;
+    }
+    editUC.finish();
+}
+exports.saveEditLabelDropAnswer = saveEditLabelDropAnswer;

package/lib/Components/LabelDrop/Controller/toggleLabelDropItemTarget.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject";
+export declare function toggleLabelDropItemTarget(id: string, appObjects: AppObjectRepo): void;

package/lib/Components/LabelDrop/Controller/toggleLabelDropItemTarget.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggleLabelDropItemTarget = void 0;
+const ToggleLabelDropTargetUC_1 = require("../UseCases/ToggleLabelDropTargetUC");
+function toggleLabelDropItemTarget(id, appObjects) {
+    const uc = ToggleLabelDropTargetUC_1.ToggleLabelDropTargetUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("toggleLabelDropItemTarget", "Unable to find ToggleLabelDropTargetUC");
+        return;
+    }
+    uc.toggleByID(id);
+}
+exports.toggleLabelDropItemTarget = toggleLabelDropItemTarget;

package/lib/Components/LabelDrop/Entities/LabelDropItemEntity.d.ts

@@ -0,0 +1,33 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+import { LabelEntity } from "../../Label/Entities";
+export interface LabelDropItemDTO {
+    id: string;
+    label: string;
+    correctAppObjectIDs: string[];
+}
+export declare class LabelDropItemEntity extends AppObjectEntity {
+    static type: string;
+    static LABEL_DROP_EMPTY: string;
+    static LABEL_DROP_TOO_LONG: string;
+    static LABEL_DROP_NEED_TARGETS: string;
+    static get(id: string, appObjects: AppObjectRepo): LabelDropItemEntity | undefined;
+    get id(): string;
+    get data(): LabelDropItemDTO;
+    set data(val: LabelDropItemDTO);
+    get label(): string;
+    set label(val: string);
+    readonly labelEntity: LabelEntity;
+    get targetValidationMessage(): string | undefined;
+    private _targetIds;
+    get targetIds(): string[];
+    set targetIds(val: string[]);
+    addTargetID: (id: string) => void;
+    removeTargetID: (id: string) => void;
+    private _tries;
+    get tries(): number;
+    private _answeredCorrectly?;
+    get answeredCorrectly(): boolean | undefined;
+    submitLabelDrop: (onObjectId: string) => boolean;
+    reset: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/LabelDrop/Entities/LabelDropItemEntity.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LabelDropItemEntity = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../Label/Entities");
+class LabelDropItemEntity extends AppObject_1.AppObjectEntity {
+    constructor(appObject) {
+        super(appObject, LabelDropItemEntity.type);
+        this._targetIds = [];
+        this.addTargetID = (id) => {
+            if (this._targetIds.includes(id))
+                return;
+            this._targetIds.push(id);
+            this.notifyOnChange();
+        };
+        this.removeTargetID = (id) => {
+            if (!this._targetIds.includes(id))
+                return;
+            this._targetIds = this._targetIds.filter((existingID) => existingID !== id);
+            this.notifyOnChange();
+        };
+        this._tries = 0;
+        this.submitLabelDrop = (onObjectId) => {
+            this._tries++;
+            this._answeredCorrectly = this._targetIds.includes(onObjectId);
+            this.notifyOnChange();
+            return this._answeredCorrectly;
+        };
+        this.reset = () => {
+            this._tries = 0;
+            this._answeredCorrectly = undefined;
+            this.notifyOnChange();
+        };
+        this.labelEntity = Entities_1.LabelEntity.addIfMissing(appObject);
+        this.labelEntity.addChangeObserver(this.notifyOnChange);
+    }
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects
+            .get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(LabelDropItemEntity.type);
+    }
+    get id() {
+        return this.appObject.id;
+    }
+    get data() {
+        return {
+            id: this.id,
+            correctAppObjectIDs: [...this._targetIds],
+            label: this.labelEntity.custom,
+        };
+    }
+    set data(val) {
+        this.labelEntity.custom = val.label;
+        this.targetIds = val.correctAppObjectIDs;
+    }
+    get label() {
+        return this.labelEntity.custom;
+    }
+    set label(val) {
+        this.labelEntity.custom = val;
+    }
+    get targetValidationMessage() {
+        if (this._targetIds.length === 0) {
+            return LabelDropItemEntity.LABEL_DROP_NEED_TARGETS;
+        }
+        else {
+            return undefined;
+        }
+    }
+    get targetIds() {
+        return [...this._targetIds];
+    }
+    set targetIds(val) {
+        this._targetIds = [...val];
+        this.notifyOnChange();
+    }
+    get tries() {
+        return this._tries;
+    }
+    get answeredCorrectly() {
+        return this._answeredCorrectly;
+    }
+}
+exports.LabelDropItemEntity = LabelDropItemEntity;
+LabelDropItemEntity.type = "LabelDropItemEntity";
+LabelDropItemEntity.LABEL_DROP_EMPTY = "Label Drop answer text cannot be empty";
+LabelDropItemEntity.LABEL_DROP_TOO_LONG = "Label Drop answer text is limited to 40 characters";
+LabelDropItemEntity.LABEL_DROP_NEED_TARGETS = "Label Drop answer must have at least one correct object";

package/lib/Components/LabelDrop/Entities/LabelDropRepo.d.ts

@@ -0,0 +1,51 @@
+import { AppObject, AppObjectEntityRepo, AppObjectRepo } from "../../../AppObject";
+import { Vector2 } from "../../../ValueObjects";
+import { Challenge } from "../../Challenge";
+import { Transform3D } from "../../Transform3D";
+import { LabelDropItemEntity } from "./LabelDropItemEntity";
+export interface LabelDropResult {
+    id: string;
+    isCorrect: boolean;
+}
+export declare enum LabelDropDragMode {
+    SCREEN = "SCREEN",
+    WORLD = "WORLD"
+}
+export declare type OnLabelDropSubmissionObserver = (result: LabelDropResult) => void;
+export declare abstract class LabelDropRepo extends AppObjectEntityRepo<LabelDropItemEntity> implements Challenge {
+    static readonly type = "LabelDropRepo";
+    readonly challengeID = "LABEL_DROP";
+    name: string;
+    helpHeading: string;
+    consumerHelpText: string;
+    authorHelpText: string;
+    static LABEL_DROP_ANSWER_REQUIRED: string;
+    abstract readonly dragLabelTransform: Transform3D;
+    abstract readonly dragHelperTransform: Transform3D;
+    abstract labelDropItemFactory(id: string): LabelDropItemEntity;
+    abstract makeLabelDropItem(id?: string): LabelDropItemEntity;
+    abstract deleteItem(id: string): void;
+    abstract deleteAllItems(): void;
+    abstract getRemainingLabelDrops: () => string[];
+    abstract submitLabelDrop: (labelDropID: string, hitAppObjectID: string) => boolean;
+    abstract reset: () => void;
+    abstract addLabelDropSubmissionObserver(observer: OnLabelDropSubmissionObserver): void;
+    abstract removeLabelDropSubmissionObserver(observer: OnLabelDropSubmissionObserver): void;
+    abstract get editingID(): string | undefined;
+    abstract set editingID(val: string | undefined);
+    abstract get isEditingNewAnswer(): boolean;
+    abstract set isEditingNewAnswer(val: boolean);
+    abstract get draggingID(): string | undefined;
+    abstract set draggingID(val: string | undefined);
+    abstract get screenPosition(): Vector2;
+    abstract set screenPosition(val: Vector2);
+    abstract get dragMode(): LabelDropDragMode;
+    abstract set dragMode(val: LabelDropDragMode);
+    abstract get resultIsCorrect(): boolean | undefined;
+    abstract set resultIsCorrect(val: boolean | undefined);
+    abstract get dragAlpha(): number;
+    abstract set dragAlpha(val: number);
+    abstract get validationMessage(): string | null;
+    static get(appObjects: AppObjectRepo): LabelDropRepo | undefined;
+}
+export declare function makeLabelDropRepo(appObj: AppObject): LabelDropRepo;

package/lib/Components/LabelDrop/Entities/LabelDropRepo.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLabelDropRepo = exports.LabelDropRepo = exports.LabelDropDragMode = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+const Utilities_1 = require("../../../Utilities");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+const LabelDropItemEntity_1 = require("./LabelDropItemEntity");
+var LabelDropDragMode;
+(function (LabelDropDragMode) {
+    LabelDropDragMode["SCREEN"] = "SCREEN";
+    LabelDropDragMode["WORLD"] = "WORLD";
+})(LabelDropDragMode = exports.LabelDropDragMode || (exports.LabelDropDragMode = {}));
+class LabelDropRepo extends AppObject_1.AppObjectEntityRepo {
+    constructor() {
+        super(...arguments);
+        this.challengeID = "LABEL_DROP";
+        this.name = "Label Drop";
+        this.helpHeading = "Label Drop Challenge Help";
+        this.consumerHelpText = "You are being challenged to drop these labels on the correct objects in the scene.";
+        this.authorHelpText = "Challenge the user to drop labels onto specific objects.";
+    }
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(LabelDropRepo.type, appObjects);
+    }
+}
+exports.LabelDropRepo = LabelDropRepo;
+LabelDropRepo.type = "LabelDropRepo";
+LabelDropRepo.LABEL_DROP_ANSWER_REQUIRED = "At least one label drop answer item is required";
+function makeLabelDropRepo(appObj) {
+    Transform3D_1.Transform3D.addIfMissing(appObj);
+    return new LabelDropRepoImp(appObj);
+}
+exports.makeLabelDropRepo = makeLabelDropRepo;
+class LabelDropRepoImp extends LabelDropRepo {
+    constructor(appObj) {
+        super(appObj, LabelDropRepo.type);
+        this._submissionObserverList = new Entities_1.ObserverList();
+        this.labelDropItemFactory = (id) => {
+            const ao = this.appObjects.getOrCreate(id);
+            return new LabelDropItemEntity_1.LabelDropItemEntity(ao);
+        };
+        this.makeLabelDropItem = (id) => {
+            const idToUse = id !== null && id !== void 0 ? id : Utilities_1.generateUniqueID();
+            const dropItem = this.labelDropItemFactory(idToUse);
+            this.add(dropItem);
+            return dropItem;
+        };
+        this.getRemainingLabelDrops = () => {
+            const remainingList = [];
+            this.getAll().forEach((item) => {
+                if (item.answeredCorrectly !== true) {
+                    remainingList.push(item.id);
+                }
+            });
+            return remainingList;
+        };
+        this.submitLabelDrop = (labelDropID, hitAppObjectID) => {
+            const item = this.getForAppObject(labelDropID);
+            if (!item) {
+                this.warn("Unable to find label drop item");
+                return false;
+            }
+            const isCorrect = item.submitLabelDrop(hitAppObjectID);
+            const result = {
+                id: labelDropID,
+                isCorrect
+            };
+            this._submissionObserverList.notify(result);
+            this.resultIsCorrect = isCorrect;
+            this.notifyOnChange();
+            return isCorrect;
+        };
+        this.reset = () => {
+            this.getAll().forEach((item) => {
+                item.reset();
+            });
+            this.notifyOnChange();
+        };
+        this._editingID = undefined;
+        this._isEditingNewAnswer = false;
+        this._draggingID = undefined;
+        this._screenPosition = ValueObjects_1.Vector2.Zero();
+        this._dragMode = LabelDropDragMode.SCREEN;
+        this._resultIsCorrect = undefined;
+        this._dragAlpha = 0;
+        this.dragLabelTransform = Transform3D_1.Transform3D.addIfMissing(appObj);
+        const dragHelperTransformAO = appObj.appObjectRepo.getOrCreate("LabelDropDragHelper");
+        this.dragHelperTransform = Transform3D_1.Transform3D.addIfMissing(dragHelperTransformAO);
+        this.appObjects.registerSingleton(this);
+    }
+    get validationMessage() {
+        if (this.getAll().length === 0) {
+            return LabelDropRepo.LABEL_DROP_ANSWER_REQUIRED;
+        }
+        else {
+            return null;
+        }
+    }
+    deleteItem(id) {
+        const item = this.getForAppObject(id);
+        if (!item)
+            return;
+        this.removeForAppObject(id);
+        item.appObject.dispose();
+    }
+    deleteAllItems() {
+        const items = this.getAll();
+        items.forEach((item) => {
+            this.removeForAppObject(item.id);
+            item.appObject.dispose();
+        });
+    }
+    get editingID() {
+        return this._editingID;
+    }
+    set editingID(val) {
+        if (val === this._editingID)
+            return;
+        if (val !== undefined && this.getForAppObject(val) === undefined)
+            return;
+        this._editingID = val;
+        this.notifyOnChange();
+    }
+    get isEditingNewAnswer() {
+        return this._isEditingNewAnswer;
+    }
+    set isEditingNewAnswer(val) {
+        if (val === this._isEditingNewAnswer)
+            return;
+        this._isEditingNewAnswer = val;
+        this.notifyOnChange();
+    }
+    get draggingID() {
+        return this._draggingID;
+    }
+    set draggingID(val) {
+        if (val === this._draggingID)
+            return;
+        this._draggingID = val;
+        this.notifyOnChange();
+    }
+    get screenPosition() {
+        return this._screenPosition;
+    }
+    set screenPosition(val) {
+        if (ValueObjects_1.Vector2.Equal(val, this._screenPosition))
+            return;
+        this._screenPosition = val;
+        this.notifyOnChange();
+    }
+    get dragMode() {
+        return this._dragMode;
+    }
+    set dragMode(val) {
+        if (val === this._dragMode)
+            return;
+        this._dragMode = val;
+        this.notifyOnChange();
+    }
+    get resultIsCorrect() {
+        return this._resultIsCorrect;
+    }
+    set resultIsCorrect(val) {
+        if (val === this._resultIsCorrect)
+            return;
+        this._resultIsCorrect = val;
+        this.notifyOnChange();
+    }
+    get dragAlpha() {
+        return this._dragAlpha;
+    }
+    set dragAlpha(val) {
+        let valToUse = val;
+        if (val < 0) {
+            valToUse = 0;
+        }
+        else if (val > 1) {
+            valToUse = 1;
+        }
+        if (valToUse === this._dragAlpha)
+            return;
+        this._dragAlpha = valToUse;
+        this.notifyOnChange();
+    }
+    addLabelDropSubmissionObserver(observer) {
+        this._submissionObserverList.add(observer);
+    }
+    removeLabelDropSubmissionObserver(observer) {
+        this._submissionObserverList.remove(observer);
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./LabelDropItemEntity";
+export * from "./LabelDropRepo";

package/lib/{PresentationManagers/HoverLabels → Components/LabelDrop/Entities}/index.js

@@ -10,5 +10,5 @@ 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("./HoverLabelPM"), exports);
-__exportStar(require("./AllowHoverLabelPM"), exports);
+__exportStar(require("./LabelDropItemEntity"), exports);
+__exportStar(require("./LabelDropRepo"), exports);

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

@@ -0,0 +1,2 @@
+export * from "./labelDropItemFactory";
+export * from "./setupLabelDrop";

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

@@ -0,0 +1,14 @@
+"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("./labelDropItemFactory"), exports);
+__exportStar(require("./setupLabelDrop"), exports);

package/lib/Components/LabelDrop/Factories/labelDropItemFactory.d.ts

@@ -0,0 +1,3 @@
+import { AppObjectRepo } from "../../../AppObject";
+import { LabelDropItemEntity } from "../Entities";
+export declare function makeLabelDropItemFactory(appObjects: AppObjectRepo): (id: string) => LabelDropItemEntity;

package/lib/Components/LabelDrop/Factories/labelDropItemFactory.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLabelDropItemFactory = void 0;
+const PM_1 = require("../../Label/PM");
+const UC_1 = require("../../Label/UC");
+const Entities_1 = require("../Entities");
+const PM_2 = require("../PM");
+const UseCases_1 = require("../UseCases");
+function makeLabelDropItemFactory(appObjects) {
+    return function labelDropItemFactory(id) {
+        const ao = appObjects.getOrCreate(id);
+        const entity = new Entities_1.LabelDropItemEntity(ao);
+        // UCs
+        new UC_1.SetCustomLabelUC(ao);
+        new UC_1.ClearCustomLabelUC(ao);
+        new UseCases_1.InitializeLabelDropLabelHook(ao);
+        // PMs
+        PM_1.makeLabelPM(ao);
+        PM_2.makeLabelDropTargetsPM(ao);
+        entity.labelEntity.customLabelValidator = UseCases_1.labelDropLabelValidator;
+        return entity;
+    };
+}
+exports.makeLabelDropItemFactory = makeLabelDropItemFactory;

package/lib/Components/LabelDrop/Factories/setupLabelDrop.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject";
+export declare function setupLabelDrop(appObjects: AppObjectRepo): void;

package/lib/Components/LabelDrop/Factories/setupLabelDrop.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupLabelDrop = void 0;
+const ValueObjects_1 = require("../../../ValueObjects");
+const Stylus_1 = require("../../Stylus");
+const Transform3D_1 = require("../../Transform3D");
+const Controller_1 = require("../Controller");
+const Entities_1 = require("../Entities");
+const PM_1 = require("../PM");
+const UseCases_1 = require("../UseCases");
+const labelDropItemFactory_1 = require("./labelDropItemFactory");
+function setupLabelDrop(appObjects) {
+    const ao = appObjects.getOrCreate("LabelDrop");
+    // Entity
+    const labelDropEntity = Entities_1.makeLabelDropRepo(ao);
+    labelDropEntity.labelDropItemFactory = labelDropItemFactory_1.makeLabelDropItemFactory(appObjects);
+    // UCs
+    new UseCases_1.SerializeLabelDrop(ao);
+    UseCases_1.makeEditLabelDropUC(ao);
+    UseCases_1.makeDragLabelDropUC(ao);
+    UseCases_1.makeDragLabelDropWorldUC(ao);
+    UseCases_1.makeDeleteLabelDropUC(ao);
+    UseCases_1.makeDeleteAllLabelDropUC(ao);
+    UseCases_1.makeToggleLabelDropTargetUC(ao);
+    UseCases_1.makeLabelDropCorrectAnimationUC(ao);
+    UseCases_1.makeLabelDropOnNothingAnimationUC(ao);
+    UseCases_1.makeLabelDropIncorrectAnimationUC(ao);
+    UseCases_1.makeValidateLabelDrop(ao);
+    // PMs
+    PM_1.makeLabelDropEditingIDPM(ao);
+    PM_1.makeRemainingLabelDropListPM(ao);
+    PM_1.makeLabelDropReviewPM(ao);
+    Transform3D_1.makeTransform3DPM(ao);
+    PM_1.makeLabelDropDragItemPM(ao);
+    PM_1.makeLabelDropListPM(ao);
+    // Controllers
+    Controller_1.makeMouseLabelDropAuthor(ao);
+    Controller_1.makeTouchLabelDropAuthor(ao);
+    Controller_1.makeStylusLabelDrop(ao);
+    const stylus = Stylus_1.StylusEntity.get(appObjects);
+    if (!stylus) {
+        appObjects.submitError("setupLabelDrop", "StylusEntity needs to be setup before Label Drop");
+    }
+    else {
+        labelDropEntity.dragHelperTransform.parent = stylus.transform;
+        labelDropEntity.dragHelperTransform.localPosition = ValueObjects_1.Vector3.Zero();
+        labelDropEntity.dragHelperTransform.localRotation = ValueObjects_1.Quaternion.Identity();
+        labelDropEntity.dragHelperTransform.localScale = ValueObjects_1.Vector3.One();
+    }
+}
+exports.setupLabelDrop = setupLabelDrop;

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

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { DeleteLabelDropUC } from "../UseCases/DeleteLabelDropUC";
+export declare class DeleteLabelDropUcMock extends DeleteLabelDropUC {
+    deleteLabelDrop: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeDeleteLabelDropUcMock(appObjects: AppObjectRepo): DeleteLabelDropUcMock;

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

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

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

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { EditLabelDropUC } from "../UseCases/EditLabelDropUC";
+export declare class EditLabelDropUcMock extends EditLabelDropUC {
+    start: jest.Mock<any, any>;
+    discard: jest.Mock<any, any>;
+    finish: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeEditLabelDropUcMock(appObjects: AppObjectRepo): EditLabelDropUcMock;