@vived/app 4.27.1 → 4.28.0

package/lib/Components/ObjectPick/Controllers/toggleIsSelectingCorrectObjectPicks.d.ts

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

package/lib/Components/ObjectPick/Controllers/toggleIsSelectingCorrectObjectPicks.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggleIsSelectingCorrectObjectPicks = void 0;
+const ObjectPickEntity_1 = require("../Entities/ObjectPickEntity");
+function toggleIsSelectingCorrectObjectPicks(appObjects) {
+    const objectPickEntity = ObjectPickEntity_1.ObjectPickEntity.get(appObjects);
+    if (!objectPickEntity) {
+        appObjects.submitWarning("toggleIsSelectingCorrectObjectPicks", "Unable to find ObjectPickEntity");
+        return;
+    }
+    objectPickEntity.isSelectingCorrectObjects =
+        !objectPickEntity.isSelectingCorrectObjects;
+}
+exports.toggleIsSelectingCorrectObjectPicks = toggleIsSelectingCorrectObjectPicks;

package/lib/Components/ObjectPick/Entities/ObjectPickEntity.d.ts

@@ -0,0 +1,22 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+import { Challenge } from "../../Challenge/Entities/ChallengeEntity";
+export declare abstract class ObjectPickEntity extends AppObjectEntity implements Challenge {
+    static readonly type = "ObjectPick";
+    static get(appObjects: AppObjectRepo): ObjectPickEntity | undefined;
+    readonly challengeID = "OBJECT_PICK";
+    authorHelpText: string;
+    consumerHelpText: string;
+    helpHeading: string;
+    name: string;
+    abstract get correctObjectIds(): string[];
+    abstract get hasSubmitted(): boolean;
+    abstract get isCorrect(): boolean;
+    abstract get isSelectingCorrectObjects(): boolean;
+    abstract set isSelectingCorrectObjects(val: boolean);
+    abstract addCorrectObjectId: (id: string) => void;
+    abstract removeCorrectObjectId: (id: string) => void;
+    abstract clearCorrectObjectIds: () => void;
+    abstract submit: (id: string) => void;
+    abstract reset: () => void;
+}
+export declare function makeObjectPickEntity(appObject: AppObject): ObjectPickEntity;

package/lib/Components/ObjectPick/Entities/ObjectPickEntity.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeObjectPickEntity = exports.ObjectPickEntity = void 0;
+const AppObject_1 = require("../../../AppObject");
+const MemoizedBoolean_1 = require("../../../Entities/MemoizedBoolean");
+class ObjectPickEntity extends AppObject_1.AppObjectEntity {
+    constructor() {
+        super(...arguments);
+        this.challengeID = "OBJECT_PICK";
+        this.authorHelpText = "Challenge the user to pick on specific object.";
+        this.consumerHelpText = "You are being challenged to pick on an object in the scene. Read the question and the pick the object that you think is correct.";
+        this.helpHeading = "Object Pick Challenge Help";
+        this.name = "Object Pick";
+    }
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(ObjectPickEntity.type, appObjects);
+    }
+}
+exports.ObjectPickEntity = ObjectPickEntity;
+ObjectPickEntity.type = "ObjectPick";
+function makeObjectPickEntity(appObject) {
+    return new ObjectPickImp(appObject);
+}
+exports.makeObjectPickEntity = makeObjectPickEntity;
+class ObjectPickImp extends ObjectPickEntity {
+    constructor(appObject) {
+        super(appObject, ObjectPickEntity.type);
+        this._submittedId = null;
+        this._correctObjectIds = [];
+        this._memoizedIsSelectingCorrectObjects = new MemoizedBoolean_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.addCorrectObjectId = (id) => {
+            if (!this._correctObjectIds.includes(id)) {
+                this._correctObjectIds.push(id);
+                this.notifyOnChange();
+            }
+        };
+        this.removeCorrectObjectId = (id) => {
+            const index = this._correctObjectIds.indexOf(id);
+            if (index !== -1) {
+                this._correctObjectIds.splice(index, 1);
+                this.notifyOnChange();
+            }
+        };
+        this.clearCorrectObjectIds = () => {
+            this._correctObjectIds = [];
+            this._submittedId = null;
+            this.notifyOnChange();
+        };
+        this.submit = (id) => {
+            this._submittedId = id;
+            this.notifyOnChange();
+        };
+        this.reset = () => {
+            this._submittedId = null;
+            this.notifyOnChange();
+        };
+        this.onAppObjectRemoved = (appObject) => {
+            if (this._correctObjectIds.includes(appObject.id)) {
+                this.removeCorrectObjectId(appObject.id);
+            }
+        };
+        this.appObjects.addAppObjectRemovedObserver(this.onAppObjectRemoved);
+    }
+    get correctObjectIds() {
+        return [...this._correctObjectIds];
+    }
+    get hasSubmitted() {
+        return this._submittedId === null ? false : true;
+    }
+    get isCorrect() {
+        if (this._submittedId !== null) {
+            return this._correctObjectIds.includes(this._submittedId);
+        }
+        return false;
+    }
+    get isSelectingCorrectObjects() {
+        return this._memoizedIsSelectingCorrectObjects.val;
+    }
+    set isSelectingCorrectObjects(val) {
+        this._memoizedIsSelectingCorrectObjects.val = val;
+    }
+}

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

@@ -0,0 +1 @@
+export * from "./ObjectPickEntity";

package/lib/Components/ObjectPick/Entities/index.js

@@ -0,0 +1,13 @@
+"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("./ObjectPickEntity"), exports);

package/lib/Components/ObjectPick/Mocks/AddCorrectObjectIdUcMock.d.ts

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

package/lib/Components/ObjectPick/Mocks/AddCorrectObjectIdUcMock.js

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

package/lib/Components/ObjectPick/Mocks/ClearCorrectObjectIdsUCMock.d.ts

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

package/lib/Components/ObjectPick/Mocks/ClearCorrectObjectIdsUCMock.js

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

package/lib/Components/ObjectPick/Mocks/ObjectPickPmMock.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { ObjectPickPM } from "../PM/ObjectPickPM";
+export declare class ObjectPickPmMock extends ObjectPickPM {
+    vmsAreEqual: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeObjectPickPmMock(appObjects: AppObjectRepo): ObjectPickPmMock;

package/lib/Components/ObjectPick/Mocks/ObjectPickPmMock.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeObjectPickPmMock = exports.ObjectPickPmMock = void 0;
+const ObjectPickPM_1 = require("../PM/ObjectPickPM");
+class ObjectPickPmMock extends ObjectPickPM_1.ObjectPickPM {
+    constructor(appObject) {
+        super(appObject, ObjectPickPM_1.ObjectPickPM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.ObjectPickPmMock = ObjectPickPmMock;
+function makeObjectPickPmMock(appObjects) {
+    return new ObjectPickPmMock(appObjects.getOrCreate("ObjectPickPmMock"));
+}
+exports.makeObjectPickPmMock = makeObjectPickPmMock;

package/lib/Components/ObjectPick/Mocks/RemoveCorrectObjectIdUcMock.d.ts

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

package/lib/Components/ObjectPick/Mocks/RemoveCorrectObjectIdUcMock.js

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

package/lib/Components/ObjectPick/Mocks/TrySelectObjectPickUCMock.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { TrySelectObjectPickUC } from "../UseCases/TrySelectObjectPickUC";
+export declare class TrySelectObjectPickUCMock extends TrySelectObjectPickUC {
+    tryWithPixel: jest.Mock<any, any>;
+    tryWithRay: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeTrySelectObjectPickUCMock(appObjects: AppObjectRepo): TrySelectObjectPickUCMock;

package/lib/Components/ObjectPick/Mocks/TrySelectObjectPickUCMock.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTrySelectObjectPickUCMock = exports.TrySelectObjectPickUCMock = void 0;
+const TrySelectObjectPickUC_1 = require("../UseCases/TrySelectObjectPickUC");
+class TrySelectObjectPickUCMock extends TrySelectObjectPickUC_1.TrySelectObjectPickUC {
+    constructor(appObject) {
+        super(appObject, TrySelectObjectPickUC_1.TrySelectObjectPickUC.type);
+        this.tryWithPixel = jest.fn();
+        this.tryWithRay = jest.fn();
+    }
+}
+exports.TrySelectObjectPickUCMock = TrySelectObjectPickUCMock;
+function makeTrySelectObjectPickUCMock(appObjects) {
+    return new TrySelectObjectPickUCMock(appObjects.getOrCreate("TrySelectObjectPickUCMock"));
+}
+exports.makeTrySelectObjectPickUCMock = makeTrySelectObjectPickUCMock;

package/lib/Components/ObjectPick/Mocks/TrySubmitObjectPickUCMock.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { TrySubmitObjectPickUC } from "../UseCases/TrySubmitObjectPickUC";
+export declare class TrySubmitObjectPickUCMock extends TrySubmitObjectPickUC {
+    tryWithPixel: jest.Mock<any, any>;
+    tryWithRay: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeTrySubmitObjectPickUCMock(appObjects: AppObjectRepo): TrySubmitObjectPickUCMock;

package/lib/Components/ObjectPick/Mocks/TrySubmitObjectPickUCMock.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTrySubmitObjectPickUCMock = exports.TrySubmitObjectPickUCMock = void 0;
+const TrySubmitObjectPickUC_1 = require("../UseCases/TrySubmitObjectPickUC");
+class TrySubmitObjectPickUCMock extends TrySubmitObjectPickUC_1.TrySubmitObjectPickUC {
+    constructor(appObject) {
+        super(appObject, TrySubmitObjectPickUC_1.TrySubmitObjectPickUC.type);
+        this.tryWithPixel = jest.fn();
+        this.tryWithRay = jest.fn();
+    }
+}
+exports.TrySubmitObjectPickUCMock = TrySubmitObjectPickUCMock;
+function makeTrySubmitObjectPickUCMock(appObjects) {
+    return new TrySubmitObjectPickUCMock(appObjects.getOrCreate("TrySubmitObjectPickUCMock"));
+}
+exports.makeTrySubmitObjectPickUCMock = makeTrySubmitObjectPickUCMock;

package/lib/Components/ObjectPick/Mocks/ValidateObjectPickUcMock.d.ts

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

package/lib/Components/ObjectPick/Mocks/ValidateObjectPickUcMock.js

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

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

@@ -0,0 +1,7 @@
+export * from "./AddCorrectObjectIdUcMock";
+export * from "./ClearCorrectObjectIdsUCMock";
+export * from "./ObjectPickPmMock";
+export * from "./RemoveCorrectObjectIdUcMock";
+export * from "./TrySelectObjectPickUCMock";
+export * from "./TrySubmitObjectPickUCMock";
+export * from "./ValidateObjectPickUcMock";

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

@@ -0,0 +1,19 @@
+"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("./AddCorrectObjectIdUcMock"), exports);
+__exportStar(require("./ClearCorrectObjectIdsUCMock"), exports);
+__exportStar(require("./ObjectPickPmMock"), exports);
+__exportStar(require("./RemoveCorrectObjectIdUcMock"), exports);
+__exportStar(require("./TrySelectObjectPickUCMock"), exports);
+__exportStar(require("./TrySubmitObjectPickUCMock"), exports);
+__exportStar(require("./ValidateObjectPickUcMock"), exports);

package/lib/Components/ObjectPick/PM/ObjectPickPM.d.ts

@@ -0,0 +1,14 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface ObjectPickVM {
+    correctObjectIds: string[];
+    isSelectingCorrectObjects: boolean;
+    hasSubmitted: boolean;
+    isCorrect: boolean;
+    validationMessage: string | null;
+}
+export declare const defaultObjectPickVM: ObjectPickVM;
+export declare abstract class ObjectPickPM extends AppObjectPM<ObjectPickVM> {
+    static readonly type = "ObjectPickPM";
+    static get(appObjects: AppObjectRepo): ObjectPickPM | undefined;
+}
+export declare function makeObjectPickPM(appObject: AppObject): ObjectPickPM;

package/lib/Components/ObjectPick/PM/ObjectPickPM.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeObjectPickPM = exports.ObjectPickPM = exports.defaultObjectPickVM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ObjectPickEntity_1 = require("../Entities/ObjectPickEntity");
+const ValidateObjectPickUC_1 = require("../UseCases/ValidateObjectPickUC");
+exports.defaultObjectPickVM = {
+    correctObjectIds: [],
+    isSelectingCorrectObjects: false,
+    hasSubmitted: false,
+    isCorrect: false,
+    validationMessage: null
+};
+class ObjectPickPM extends AppObject_1.AppObjectPM {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(ObjectPickPM.type, appObjects);
+    }
+}
+exports.ObjectPickPM = ObjectPickPM;
+ObjectPickPM.type = "ObjectPickPM";
+function makeObjectPickPM(appObject) {
+    return new ObjectPickPMImp(appObject);
+}
+exports.makeObjectPickPM = makeObjectPickPM;
+class ObjectPickPMImp extends ObjectPickPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, ObjectPickPM.type);
+        this.onEntityChange = () => {
+            if (!this.objectPick)
+                return;
+            if (!this.validateObjectPickUC)
+                return;
+            const vm = {
+                correctObjectIds: this.objectPick.correctObjectIds,
+                isSelectingCorrectObjects: this.objectPick.isSelectingCorrectObjects,
+                hasSubmitted: this.objectPick.hasSubmitted,
+                isCorrect: this.objectPick.isCorrect,
+                validationMessage: this.validateObjectPickUC.validateObjectPick()
+            };
+            this.doUpdateView(vm);
+        };
+        (_a = this.objectPick) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+        this.appObjects.registerSingleton(this);
+    }
+    get objectPick() {
+        return this.getCachedSingleton(ObjectPickEntity_1.ObjectPickEntity.type);
+    }
+    get validateObjectPickUC() {
+        return this.getCachedSingleton(ValidateObjectPickUC_1.ValidateObjectPickUC.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.correctObjectIds.length !== b.correctObjectIds.length)
+            return false;
+        if (a.hasSubmitted !== b.hasSubmitted)
+            return false;
+        if (a.isSelectingCorrectObjects !== b.isSelectingCorrectObjects)
+            return false;
+        if (a.validationMessage !== b.validationMessage)
+            return false;
+        if (a.isCorrect !== b.isCorrect)
+            return false;
+        let listsAreTheSame = true;
+        a.correctObjectIds.forEach((objA, i) => {
+            const objB = b.correctObjectIds[i];
+            if (objA !== objB)
+                listsAreTheSame = false;
+        });
+        return listsAreTheSame;
+    }
+}

package/lib/Components/ObjectPick/PM/index.d.ts

@@ -0,0 +1 @@
+export * from "./ObjectPickPM";

package/lib/{AppObjectComponents/Mesh → Components/ObjectPick/PM}/index.js

@@ -10,4 +10,4 @@ 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("./Entities/Mesh"), exports);
+__exportStar(require("./ObjectPickPM"), exports);

package/lib/Components/ObjectPick/UseCases/AddCorrectObjectIdUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class AddCorrectObjectIdUC extends AppObjectUC {
+    static readonly type = "AddCorrectObjectIdUC";
+    abstract addCorrectObjectId(id: string): void;
+    static get(appObjects: AppObjectRepo): AddCorrectObjectIdUC | undefined;
+}
+export declare function makeAddCorrectObjectIdUC(appObject: AppObject): AddCorrectObjectIdUC;

package/lib/Components/ObjectPick/UseCases/AddCorrectObjectIdUC.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAddCorrectObjectIdUC = exports.AddCorrectObjectIdUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const ObjectPickEntity_1 = require("../Entities/ObjectPickEntity");
+class AddCorrectObjectIdUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(AddCorrectObjectIdUC.type, appObjects);
+    }
+}
+exports.AddCorrectObjectIdUC = AddCorrectObjectIdUC;
+AddCorrectObjectIdUC.type = "AddCorrectObjectIdUC";
+function makeAddCorrectObjectIdUC(appObject) {
+    return new AddCorrectObjectIdUCImp(appObject);
+}
+exports.makeAddCorrectObjectIdUC = makeAddCorrectObjectIdUC;
+class AddCorrectObjectIdUCImp extends AddCorrectObjectIdUC {
+    constructor(appObject) {
+        super(appObject, AddCorrectObjectIdUC.type);
+        this.addCorrectObjectId = (id) => {
+            var _a;
+            if (!this.objectPick)
+                return;
+            this.objectPick.addCorrectObjectId(id);
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+            const objectPick = this.objectPick;
+            (_a = this.undo) === null || _a === void 0 ? void 0 : _a.submitAction({
+                redoAction: () => {
+                    objectPick.addCorrectObjectId(id);
+                    Dispatcher_1.dispatchStateChange(this.appObjects);
+                },
+                undoAction: () => {
+                    objectPick.removeCorrectObjectId(id);
+                    Dispatcher_1.dispatchStateChange(this.appObjects);
+                },
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get undo() {
+        return this.getCachedSingleton(UndoRedoEntity_1.UndoRedoEntity.type);
+    }
+    get objectPick() {
+        return this.getCachedSingleton(ObjectPickEntity_1.ObjectPickEntity.type);
+    }
+}

package/lib/Components/ObjectPick/UseCases/ClearCorrectObjectIdsUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class ClearCorrectObjectIdsUC extends AppObjectUC {
+    static readonly type = "ClearCorrectObjectIdsUC";
+    abstract clearCorrectObjectIds(): void;
+    static get(appObjects: AppObjectRepo): ClearCorrectObjectIdsUC | undefined;
+}
+export declare function makeClearCorrectObjectIdsUC(appObject: AppObject): ClearCorrectObjectIdsUC;

package/lib/Components/ObjectPick/UseCases/ClearCorrectObjectIdsUC.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeClearCorrectObjectIdsUC = exports.ClearCorrectObjectIdsUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const ObjectPickEntity_1 = require("../Entities/ObjectPickEntity");
+class ClearCorrectObjectIdsUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(ClearCorrectObjectIdsUC.type, appObjects);
+    }
+}
+exports.ClearCorrectObjectIdsUC = ClearCorrectObjectIdsUC;
+ClearCorrectObjectIdsUC.type = "ClearCorrectObjectIdsUC";
+function makeClearCorrectObjectIdsUC(appObject) {
+    return new ClearCorrectObjectIdsUCImp(appObject);
+}
+exports.makeClearCorrectObjectIdsUC = makeClearCorrectObjectIdsUC;
+class ClearCorrectObjectIdsUCImp extends ClearCorrectObjectIdsUC {
+    constructor(appObject) {
+        super(appObject, ClearCorrectObjectIdsUC.type);
+        this.clearCorrectObjectIds = () => {
+            var _a;
+            const objectPick = this.objectPick;
+            if (!objectPick)
+                return;
+            const clearedIds = [...objectPick.correctObjectIds];
+            if (clearedIds.length === 0)
+                return;
+            objectPick.clearCorrectObjectIds();
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+            (_a = this.undo) === null || _a === void 0 ? void 0 : _a.submitAction({
+                redoAction: () => {
+                    clearedIds.forEach((id) => {
+                        objectPick.removeCorrectObjectId(id);
+                    });
+                    DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+                },
+                undoAction: () => {
+                    clearedIds.forEach((id) => {
+                        objectPick.addCorrectObjectId(id);
+                    });
+                    DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+                },
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get undo() {
+        return this.getCachedSingleton(UndoRedoEntity_1.UndoRedoEntity.type);
+    }
+    get objectPick() {
+        return this.getCachedSingleton(ObjectPickEntity_1.ObjectPickEntity.type);
+    }
+}

package/lib/Components/ObjectPick/UseCases/RemoveCorrectObjectIdUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class RemoveCorrectObjectIdUC extends AppObjectUC {
+    static readonly type = "RemoveCorrectObjectIdUC";
+    abstract removeCorrectObjectId(id: string): void;
+    static get(appObjects: AppObjectRepo): RemoveCorrectObjectIdUC | undefined;
+}
+export declare function makeRemoveCorrectObjectIdUC(appObject: AppObject): RemoveCorrectObjectIdUC;

package/lib/Components/ObjectPick/UseCases/RemoveCorrectObjectIdUC.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRemoveCorrectObjectIdUC = exports.RemoveCorrectObjectIdUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const ObjectPickEntity_1 = require("../Entities/ObjectPickEntity");
+class RemoveCorrectObjectIdUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(RemoveCorrectObjectIdUC.type, appObjects);
+    }
+}
+exports.RemoveCorrectObjectIdUC = RemoveCorrectObjectIdUC;
+RemoveCorrectObjectIdUC.type = "RemoveCorrectObjectIdUC";
+function makeRemoveCorrectObjectIdUC(appObject) {
+    return new RemoveCorrectObjectIdUCImp(appObject);
+}
+exports.makeRemoveCorrectObjectIdUC = makeRemoveCorrectObjectIdUC;
+class RemoveCorrectObjectIdUCImp extends RemoveCorrectObjectIdUC {
+    constructor(appObject) {
+        super(appObject, RemoveCorrectObjectIdUC.type);
+        this.removeCorrectObjectId = (id) => {
+            var _a;
+            const objectPick = this.objectPick;
+            if (!objectPick)
+                return;
+            objectPick.removeCorrectObjectId(id);
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+            (_a = this.undo) === null || _a === void 0 ? void 0 : _a.submitAction({
+                redoAction: () => {
+                    objectPick.removeCorrectObjectId(id);
+                    DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+                },
+                undoAction: () => {
+                    objectPick.addCorrectObjectId(id);
+                    DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+                },
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get undo() {
+        return this.getCachedSingleton(UndoRedoEntity_1.UndoRedoEntity.type);
+    }
+    get objectPick() {
+        return this.getCachedSingleton(ObjectPickEntity_1.ObjectPickEntity.type);
+    }
+}