@vived/app 4.26.1 → 4.27.0

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);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { SerializedSystem } from "../../StateMachine";
+export declare class SerializeObjectPick extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeObjectPick";
+    name: string;
+    seriliziationVersion: number;
+    private objectPick;
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    private applyStateV1;
+    applyDefaultState(): void;
+    constructor(appObject: AppObject);
+}
+export interface SerializedObjectPickV1 {
+    correctObjectIds: string[];
+}

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeObjectPick = void 0;
+const AppObject_1 = require("../../../AppObject");
+const StateMachine_1 = require("../../StateMachine");
+const ObjectPickEntity_1 = require("../Entities/ObjectPickEntity");
+class SerializeObjectPick extends AppObject_1.AppObjectUC {
+    constructor(appObject) {
+        super(appObject, SerializeObjectPick.type);
+        this.name = "object-pick";
+        this.seriliziationVersion = 1;
+        const objectPick = ObjectPickEntity_1.ObjectPickEntity.get(this.appObjects);
+        if (!objectPick) {
+            throw new Error("[SerializeObjectPick] App Object does not have a Object Pick Entity. Add one");
+        }
+        this.objectPick = objectPick;
+        const stateMachine = StateMachine_1.StateMachineEntity.get(appObject.appObjectRepo);
+        if (stateMachine) {
+            stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            this.warn("Unable to find StateMachineEntity");
+        }
+    }
+    getSystemState() {
+        const state = {
+            correctObjectIds: this.objectPick.correctObjectIds,
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (version === 1) {
+            this.applyStateV1(state);
+        }
+        else {
+            this.applyDefaultState();
+        }
+    }
+    applyStateV1(state) {
+        if (state.correctObjectIds === undefined) {
+            this.applyDefaultState();
+            return;
+        }
+        this.objectPick.clearCorrectObjectIds();
+        state.correctObjectIds.forEach((id) => {
+            this.objectPick.addCorrectObjectId(id);
+        });
+    }
+    applyDefaultState() {
+        this.objectPick.clearCorrectObjectIds();
+    }
+}
+exports.SerializeObjectPick = SerializeObjectPick;
+SerializeObjectPick.type = "SerializeObjectPick";

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

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { ParametricLine, Vector2 } from "../../../ValueObjects";
+export declare abstract class TrySelectObjectPickUC extends AppObjectUC {
+    static readonly type = "TrySelectObjectPickUC";
+    abstract tryWithRay(ray: ParametricLine): void;
+    abstract tryWithPixel(pixel: Vector2): void;
+    static get(appObjects: AppObjectRepo): TrySelectObjectPickUC | undefined;
+}
+export declare function makeTrySelectObjectPickUC(appObject: AppObject): TrySelectObjectPickUC;

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTrySelectObjectPickUC = exports.TrySelectObjectPickUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const BaseAppState_1 = require("../../BaseApp/Entity/BaseAppState");
+const UC_1 = require("../../Babylon/UC");
+const ChallengeEntity_1 = require("../../Challenge/Entities/ChallengeEntity");
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedo_1 = require("../../UndoRedo");
+const ObjectPickEntity_1 = require("../Entities/ObjectPickEntity");
+class TrySelectObjectPickUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(TrySelectObjectPickUC.type, appObjects);
+    }
+}
+exports.TrySelectObjectPickUC = TrySelectObjectPickUC;
+TrySelectObjectPickUC.type = "TrySelectObjectPickUC";
+function makeTrySelectObjectPickUC(appObject) {
+    return new TrySelectObjectPickUCImp(appObject);
+}
+exports.makeTrySelectObjectPickUC = makeTrySelectObjectPickUC;
+class TrySelectObjectPickUCImp extends TrySelectObjectPickUC {
+    constructor(appObject) {
+        super(appObject, TrySelectObjectPickUC.type);
+        this.tryWithPixel = (pixel) => {
+            if (!this.pixelToRay) {
+                this.error("Missing component");
+                return;
+            }
+            const ray = this.pixelToRay(pixel);
+            return this.tryWithRay(ray);
+        };
+        this.tryWithRay = (ray) => {
+            var _a, _b, _c, _d;
+            if (!this.baseApp)
+                return;
+            if (!this.objectPick)
+                return;
+            if (!this.baseApp.isAuthoring) {
+                return;
+            }
+            if (!this.objectPick.isSelectingCorrectObjects) {
+                return;
+            }
+            if (((_a = this.challenge) === null || _a === void 0 ? void 0 : _a.selectedChallenge) !== this.objectPick.challengeID) {
+                return;
+            }
+            const appObjectID = (_c = (_b = UC_1.SceneRayPickUC.get(this.appObjects)) === null || _b === void 0 ? void 0 : _b.sceneRayPick(ray)) === null || _c === void 0 ? void 0 : _c.appObjectID;
+            if (!appObjectID) {
+                return;
+            }
+            this.objectPick.addCorrectObjectId(appObjectID);
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+            const objectPick = this.objectPick;
+            (_d = this.undo) === null || _d === void 0 ? void 0 : _d.submitAction({
+                redoAction: () => {
+                    objectPick.addCorrectObjectId(appObjectID);
+                    DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+                },
+                undoAction: () => {
+                    objectPick.removeCorrectObjectId(appObjectID);
+                    DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+                },
+            });
+        };
+    }
+    get baseApp() {
+        return this.getCachedSingleton(BaseAppState_1.BaseAppState.type);
+    }
+    get challenge() {
+        return this.getCachedSingleton(ChallengeEntity_1.ChallengeEntity.type);
+    }
+    get objectPick() {
+        return this.getCachedSingleton(ObjectPickEntity_1.ObjectPickEntity.type);
+    }
+    get pixelToRay() {
+        var _a;
+        return (_a = this.getCachedSingleton(UC_1.PixelToSceneRayUC.type)) === null || _a === void 0 ? void 0 : _a.pixelToSceneRay;
+    }
+    get undo() {
+        return this.getCachedSingleton(UndoRedo_1.UndoRedoEntity.type);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { ParametricLine, Vector2 } from "../../../ValueObjects";
+export declare abstract class TrySubmitObjectPickUC extends AppObjectUC {
+    static readonly type = "TrySubmitObjectPickUC";
+    abstract tryWithRay(ray: ParametricLine): void;
+    abstract tryWithPixel(pixel: Vector2): void;
+    static get(appObjects: AppObjectRepo): TrySubmitObjectPickUC | undefined;
+}
+export declare function makeTrySubmitObjectPickUC(appObject: AppObject): TrySubmitObjectPickUC;

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTrySubmitObjectPickUC = exports.TrySubmitObjectPickUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const BaseAppState_1 = require("../../BaseApp/Entity/BaseAppState");
+const UC_1 = require("../../Babylon/UC");
+const ChallengeEntity_1 = require("../../Challenge/Entities/ChallengeEntity");
+const SubmitResultResultUC_1 = require("../../Dispatcher/UC/SubmitResultResultUC");
+const ObjectPickEntity_1 = require("../Entities/ObjectPickEntity");
+class TrySubmitObjectPickUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(TrySubmitObjectPickUC.type, appObjects);
+    }
+}
+exports.TrySubmitObjectPickUC = TrySubmitObjectPickUC;
+TrySubmitObjectPickUC.type = "TrySubmitObjectPickUC";
+function makeTrySubmitObjectPickUC(appObject) {
+    return new TrySubmitObjectPickUCImp(appObject);
+}
+exports.makeTrySubmitObjectPickUC = makeTrySubmitObjectPickUC;
+class TrySubmitObjectPickUCImp extends TrySubmitObjectPickUC {
+    constructor(appObject) {
+        super(appObject, TrySubmitObjectPickUC.type);
+        this.tryWithPixel = (pixel) => {
+            if (!this.pixelToRay) {
+                this.error("Missing component");
+                return;
+            }
+            const ray = this.pixelToRay(pixel);
+            return this.tryWithRay(ray);
+        };
+        this.tryWithRay = (ray) => {
+            var _a, _b;
+            if (!this.baseApp || !this.challenge || !this.objectPick)
+                return;
+            if (this.baseApp.isAuthoring)
+                return;
+            if (this.baseApp.isReviewing)
+                return;
+            if (this.challenge.selectedChallenge !== "OBJECT_PICK")
+                return;
+            const sceneObjectId = (_b = (_a = UC_1.SceneRayPickUC.get(this.appObjects)) === null || _a === void 0 ? void 0 : _a.sceneRayPick(ray)) === null || _b === void 0 ? void 0 : _b.appObjectID;
+            if (!sceneObjectId) {
+                return;
+            }
+            this.objectPick.submit(sceneObjectId);
+            const result = {
+                description: this.baseApp.slideText,
+                success: this.objectPick.hasSubmitted,
+            };
+            SubmitResultResultUC_1.submitHitResult(result, this.appObjects);
+            this.baseApp.isReviewing = true;
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get baseApp() {
+        return this.getCachedSingleton(BaseAppState_1.BaseAppState.type);
+    }
+    get challenge() {
+        return this.getCachedSingleton(ChallengeEntity_1.ChallengeEntity.type);
+    }
+    get objectPick() {
+        return this.getCachedSingleton(ObjectPickEntity_1.ObjectPickEntity.type);
+    }
+    get pixelToRay() {
+        var _a;
+        return (_a = this.getCachedSingleton(UC_1.PixelToSceneRayUC.type)) === null || _a === void 0 ? void 0 : _a.pixelToSceneRay;
+    }
+}

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

@@ -0,0 +1,10 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class ValidateObjectPickUC extends AppObjectUC {
+    static readonly type = "ValidateObjectPickUC";
+    abstract validateObjectPick(): string | null;
+    static get(appObjects: AppObjectRepo): ValidateObjectPickUC | undefined;
+    OBJECT_PICK_CHALLENGE_NO_SLIDE_TEXT: string;
+    OBJECT_PICK_ENTITY_SHOULD_HAVE_AT_LEAST_ONE_ID: string;
+    OBJECT_PICK_ENTITY_SHOULD_HAVE_AT_LEAST_ONE_VISIBLE_OBJECT: string;
+}
+export declare function makeValidateObjectPickUC(appObject: AppObject): ValidateObjectPickUC;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeValidateObjectPickUC = exports.ValidateObjectPickUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const BaseApp_1 = require("../../BaseApp");
+const Hideable_1 = require("../../Hideable");
+const ObjectPickEntity_1 = require("../Entities/ObjectPickEntity");
+class ValidateObjectPickUC extends AppObject_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.OBJECT_PICK_CHALLENGE_NO_SLIDE_TEXT = "A question in the slide text is required.";
+        this.OBJECT_PICK_ENTITY_SHOULD_HAVE_AT_LEAST_ONE_ID = "Object Pick Entity should have at least one ID.";
+        this.OBJECT_PICK_ENTITY_SHOULD_HAVE_AT_LEAST_ONE_VISIBLE_OBJECT = "Object Pick Entity should have at least one visible object ID.";
+    }
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(ValidateObjectPickUC.type, appObjects);
+    }
+}
+exports.ValidateObjectPickUC = ValidateObjectPickUC;
+ValidateObjectPickUC.type = "ValidateObjectPickUC";
+function makeValidateObjectPickUC(appObject) {
+    return new ValidateObjectPickUCImp(appObject);
+}
+exports.makeValidateObjectPickUC = makeValidateObjectPickUC;
+class ValidateObjectPickUCImp extends ValidateObjectPickUC {
+    constructor(appObject) {
+        super(appObject, ValidateObjectPickUC.type);
+        this.validateObjectPick = () => {
+            if (!this.baseApp || !this.objectPick)
+                return null;
+            if (!this.baseApp.slideText) {
+                return this.OBJECT_PICK_CHALLENGE_NO_SLIDE_TEXT;
+            }
+            if (this.objectPick.correctObjectIds.length < 1) {
+                return this.OBJECT_PICK_ENTITY_SHOULD_HAVE_AT_LEAST_ONE_ID;
+            }
+            if (this.objectPick.correctObjectIds.length > 0) {
+                let objectsShown = false;
+                this.objectPick.correctObjectIds.forEach((id) => {
+                    const hideable = this.appObjects.getAppObjectComponent(id, Hideable_1.Hideable.type);
+                    if (!hideable) {
+                        objectsShown = true;
+                    }
+                    else if (!hideable.isHidden) {
+                        objectsShown = true;
+                    }
+                });
+                if (!objectsShown) {
+                    return this.OBJECT_PICK_ENTITY_SHOULD_HAVE_AT_LEAST_ONE_VISIBLE_OBJECT;
+                }
+            }
+            return null;
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get baseApp() {
+        return this.getCachedSingleton(BaseApp_1.BaseAppState.type);
+    }
+    get objectPick() {
+        return this.getCachedSingleton(ObjectPickEntity_1.ObjectPickEntity.type);
+    }
+}

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

@@ -0,0 +1,7 @@
+export * from "./AddCorrectObjectIdUC";
+export * from "./ClearCorrectObjectIdsUC";
+export * from "./RemoveCorrectObjectIdUC";
+export * from "./SerializeObjectPick";
+export * from "./TrySelectObjectPickUC";
+export * from "./TrySubmitObjectPickUC";
+export * from "./ValidateObjectPickUC";

package/lib/Components/ObjectPick/UseCases/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("./AddCorrectObjectIdUC"), exports);
+__exportStar(require("./ClearCorrectObjectIdsUC"), exports);
+__exportStar(require("./RemoveCorrectObjectIdUC"), exports);
+__exportStar(require("./SerializeObjectPick"), exports);
+__exportStar(require("./TrySelectObjectPickUC"), exports);
+__exportStar(require("./TrySubmitObjectPickUC"), exports);
+__exportStar(require("./ValidateObjectPickUC"), exports);

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

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

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

package/lib/Components/Question/UC/registerQuestionChallenge.d.ts

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

package/lib/Components/Question/UC/registerQuestionChallenge.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerQuestionChallenge = void 0;
+const ChallengeEntity_1 = require("../../Challenge/Entities/ChallengeEntity");
+function registerQuestionChallenge(appObjects) {
+    const entity = ChallengeEntity_1.ChallengeEntity.get(appObjects);
+    if (!entity) {
+        appObjects.submitError("registerQuestionChallenge", "Unable to find ChallengeEntity");
+        return;
+    }
+    const challengeDetails = {
+        authorHelpText: "Challenge the user to answer a multiple choice question.",
+        consumerHelpText: "You are being challenged to answer a question. Read the question and select the answer you think is correct.",
+        helpHeading: "Question Challenge Help",
+        id: "QUESTION",
+        name: "Question",
+    };
+    entity === null || entity === void 0 ? void 0 : entity.registerChallenge(challengeDetails);
+}
+exports.registerQuestionChallenge = registerQuestionChallenge;

package/lib/Components/Stylus/Adapters/index.d.ts

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

package/lib/Components/Stylus/Adapters/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("./stylusIsInUseAdapter"), exports);

package/lib/Components/Stylus/Adapters/stylusIsInUseAdapter.d.ts

@@ -0,0 +1,2 @@
+import { SingletonPmAdapter } from "../../../Types";
+export declare const stylusIsInUseAdapter: SingletonPmAdapter<boolean>;

package/lib/Components/Stylus/Adapters/stylusIsInUseAdapter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stylusIsInUseAdapter = void 0;
+const StylusIsInUsePM_1 = require("../PMs/StylusIsInUsePM");
+exports.stylusIsInUseAdapter = {
+    defaultVM: false,
+    subscribe: (appObjects, setVM) => {
+        const pm = StylusIsInUsePM_1.StylusIsInUsePM.get(appObjects);
+        if (!pm) {
+            appObjects.submitError("stylusIsInUseAdapter", "Unable to find StylusIsInUsePM");
+            return;
+        }
+        pm.addView(setVM);
+    },
+    unsubscribe: (appObjects, setVM) => {
+        const pm = StylusIsInUsePM_1.StylusIsInUsePM.get(appObjects);
+        pm === null || pm === void 0 ? void 0 : pm.removeView(setVM);
+    },
+};

package/lib/Components/Stylus/Mocks/StylusIsInUsePMMock.d.ts

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

package/lib/Components/Stylus/Mocks/StylusIsInUsePMMock.js

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

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

@@ -1 +1,2 @@
 export * from "./MockEmulateStylusUC";
+export * from "./StylusIsInUsePMMock";

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

@@ -11,3 +11,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./MockEmulateStylusUC"), exports);
+__exportStar(require("./StylusIsInUsePMMock"), exports);

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

@@ -1,3 +1,4 @@
+export * from "./Adapters";
 export * from "./Entity";
 export * from "./Mocks";
 export * from "./PMs";

package/lib/Components/Stylus/index.js

@@ -10,6 +10,7 @@ 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("./Entity"), exports);
 __exportStar(require("./Mocks"), exports);
 __exportStar(require("./PMs"), exports);

package/lib/Components/Transform3D/Controllers/Mouse/TryMousePanTransformMC.d.ts

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { MouseController, MouseInputEvent } from "../../../MouseInput";
+export declare class TryMousePanTransformMC extends AppObjectController implements MouseController {
+    static readonly type = "TryMousePanTransformMC";
+    allow: (e: MouseInputEvent) => boolean;
+    private get mouseInput();
+    private get tryScreenDragUC();
+    private isDragging;
+    onDown: (e: MouseInputEvent) => void;
+    onMove: (e: MouseInputEvent) => void;
+    onUp: () => void;
+    constructor(appObject: AppObject);
+}