@vived/app 3.8.0 → 3.9.1

package/lib/AppObjectComponents/Question/UseCases/SetAnswerFeedbackUC.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetAnswerFeedbackUC = exports.SetAnswerFeedbackUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+class SetAnswerFeedbackUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.SetAnswerFeedbackUC = SetAnswerFeedbackUC;
+SetAnswerFeedbackUC.type = "SetAnswerFeedbackUC";
+function makeSetAnswerFeedbackUC(appObject) {
+    return new SetAnswerFeedbackUCImp(appObject);
+}
+exports.makeSetAnswerFeedbackUC = makeSetAnswerFeedbackUC;
+class SetAnswerFeedbackUCImp extends SetAnswerFeedbackUC {
+    constructor(appObject) {
+        super(appObject, SetAnswerFeedbackUC.type);
+        this.answer = appObject.getComponent(QuestionAnswerEntity_1.QuestionAnswerEntity.type);
+        if (!this.answer) {
+            App_1.submitWarning("SetAnswerFeedbackUC", "SetAnswerFeedbackUC has been added to an app object that does not have QuestionAnswerEntity", appObject.appObjectRepo);
+        }
+    }
+    setFeedback(feedback) {
+        var _a;
+        if (!this.answer)
+            return;
+        if (this.answer.feedbackText === feedback)
+            return;
+        this.answer.feedbackText = feedback;
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+    }
+}

package/lib/AppObjectComponents/Question/UseCases/SetAnswerTextUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class SetAnswerTextUC extends AppObjectUC {
+    static readonly type = "SetAnswerTextUC";
+    abstract setText(text: string): void;
+}
+export declare function makeSetAnswerTextUC(appObject: AppObject): SetAnswerTextUC;

package/lib/AppObjectComponents/Question/UseCases/SetAnswerTextUC.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetAnswerTextUC = exports.SetAnswerTextUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+class SetAnswerTextUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.SetAnswerTextUC = SetAnswerTextUC;
+SetAnswerTextUC.type = "SetAnswerTextUC";
+function makeSetAnswerTextUC(appObject) {
+    return new SetAnswerTextUCImp(appObject);
+}
+exports.makeSetAnswerTextUC = makeSetAnswerTextUC;
+class SetAnswerTextUCImp extends SetAnswerTextUC {
+    constructor(appObject) {
+        super(appObject, SetAnswerTextUC.type);
+        this.answer = appObject.getComponent(QuestionAnswerEntity_1.QuestionAnswerEntity.type);
+        if (!this.answer) {
+            App_1.submitWarning("SetAnswerTextUC", "SetAnswerTextUC has been added to an app object that does not have QuestionAnswerEntity", appObject.appObjectRepo);
+        }
+    }
+    setText(text) {
+        var _a;
+        if (!this.answer)
+            return;
+        if (this.answer.text === text)
+            return;
+        this.answer.text = text;
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+    }
+}

package/lib/AppObjectComponents/Question/UseCases/SetQuesionAnswerFeedback.d.ts

@@ -0,0 +1,2 @@
+import { QuestionChallenge } from "../../Entities";
+export declare function makeSetQuestionChallengeAnswerFeedback(answerID: string, questionChallenge: QuestionChallenge): (feedback: string) => void;

package/lib/AppObjectComponents/Question/UseCases/SetQuesionAnswerFeedback.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetQuestionChallengeAnswerFeedback = void 0;
+function makeSetQuestionChallengeAnswerFeedback(answerID, questionChallenge) {
+    return function setQuestionChallengeAnswerFeedback(feedback) {
+        const answer = questionChallenge.getAnswer(answerID);
+        if (answer) {
+            answer.feedbackText = feedback;
+        }
+        else {
+            console.warn("[setQuestionChallengeAnswerFeedback] Unable to find question by id " +
+                answerID);
+        }
+    };
+}
+exports.makeSetQuestionChallengeAnswerFeedback = makeSetQuestionChallengeAnswerFeedback;

package/lib/AppObjectComponents/Question/UseCases/SubmitQuestionAnswerUC.d.ts

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

package/lib/AppObjectComponents/Question/UseCases/SubmitQuestionAnswerUC.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSubmitQuestionAnswerUC = exports.SubmitQuestionAnswerUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entities_1 = require("../Entities");
+class SubmitQuestionAnswerUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(SubmitQuestionAnswerUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("SubmitQuestionAnswerUC", `Unable to find component ${SubmitQuestionAnswerUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("SubmitQuestionAnswerUC", `Multiple ${SubmitQuestionAnswerUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.SubmitQuestionAnswerUC = SubmitQuestionAnswerUC;
+SubmitQuestionAnswerUC.type = "SubmitQuestionAnswerUC";
+function makeSubmitQuestionAnswerUC(appObject) {
+    return new SubmitQuestionAnswerUCImp(appObject);
+}
+exports.makeSubmitQuestionAnswerUC = makeSubmitQuestionAnswerUC;
+class SubmitQuestionAnswerUCImp extends SubmitQuestionAnswerUC {
+    constructor(appObject) {
+        super(appObject, SubmitQuestionAnswerUC.type);
+        this.questionEntity = appObject.getComponent(Entities_1.QuestionEntity.type);
+        if (!this.questionEntity) {
+            App_1.submitWarning("SubmitQuestionAnswerUCImp", "SubmitQuestionAnswerUCImp has been added to an app object that does not have QuestionEntity", appObject.appObjectRepo);
+        }
+    }
+    submitAnswer(id) {
+        if (!this.questionEntity)
+            return;
+        if (!this.questionEntity.hasAnswer(id)) {
+            App_1.submitWarning("SubmitQuestionAnswerUCImp", "Unable to find answer by ID", this.appObject.appObjectRepo);
+            return;
+        }
+        const baseApp = App_1.BaseAppState.get(this.appObject.appObjectRepo);
+        if (!baseApp) {
+            App_1.submitWarning("SubmitQuestionAnswerUCImp", "Unable to find Base App", this.appObject.appObjectRepo);
+            return;
+        }
+        if (baseApp.isAuthoring)
+            return;
+        this.questionEntity.submitAnswer(id);
+        const submitResult = Dispatcher_1.SubmitResultResultUC.get(this.appObject.appObjectRepo);
+        if (submitResult) {
+            submitResult.submitHitResult({
+                success: this.questionEntity.gotItRight,
+                description: baseApp.slideText,
+            });
+        }
+        baseApp.isReviewing = true;
+    }
+}

package/lib/AppObjectComponents/Question/UseCases/ToggleQuestionAnswerIsCorrect.d.ts

@@ -0,0 +1,7 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class ToggleQuesionChallengeAnswerIsCorrectUC extends AppObjectUC {
+    static readonly type = "ToggleQuesionChallengeAnswerIsCorrect";
+    abstract toggleIsCorrect(): void;
+}
+export declare function makeToggleQuesionChallengeAnswerIsCorrectUC(appObject: AppObject): ToggleQuesionChallengeAnswerIsCorrectUC;

package/lib/AppObjectComponents/Question/UseCases/ToggleQuestionAnswerIsCorrect.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeToggleQuesionChallengeAnswerIsCorrectUC = exports.ToggleQuesionChallengeAnswerIsCorrectUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+class ToggleQuesionChallengeAnswerIsCorrectUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.ToggleQuesionChallengeAnswerIsCorrectUC = ToggleQuesionChallengeAnswerIsCorrectUC;
+ToggleQuesionChallengeAnswerIsCorrectUC.type = "ToggleQuesionChallengeAnswerIsCorrect";
+function makeToggleQuesionChallengeAnswerIsCorrectUC(appObject) {
+    return new ToggleQuesionChallengeAnswerIsCorrectImp(appObject);
+}
+exports.makeToggleQuesionChallengeAnswerIsCorrectUC = makeToggleQuesionChallengeAnswerIsCorrectUC;
+class ToggleQuesionChallengeAnswerIsCorrectImp extends ToggleQuesionChallengeAnswerIsCorrectUC {
+    constructor(appObject) {
+        super(appObject, ToggleQuesionChallengeAnswerIsCorrectUC.type);
+        this.answer = appObject.getComponent(QuestionAnswerEntity_1.QuestionAnswerEntity.type);
+        if (!this.answer) {
+            App_1.submitWarning("ToggleQuesionChallengeAnswerIsCorrectUC", "ToggleQuesionChallengeAnswerIsCorrectUC has been added to an app object that does not have QuestionAnswerEntity", appObject.appObjectRepo);
+        }
+    }
+    toggleIsCorrect() {
+        var _a;
+        if (!this.answer)
+            return;
+        this.answer.isCorrect = !this.answer.isCorrect;
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+    }
+}

package/lib/AppObjectComponents/Question/UseCases/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./AddQuestionAnswerUC";
+export * from "./DeleteQuestionAnswerUC";
+export * from "./SerializeQuestionChallenge";
+export * from "./SetAnswerFeedbackUC";
+export * from "./SetAnswerTextUC";
+export * from "./SubmitQuestionAnswerUC";
+export * from "./ToggleQuestionAnswerIsCorrect";

package/lib/AppObjectComponents/Question/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("./AddQuestionAnswerUC"), exports);
+__exportStar(require("./DeleteQuestionAnswerUC"), exports);
+__exportStar(require("./SerializeQuestionChallenge"), exports);
+__exportStar(require("./SetAnswerFeedbackUC"), exports);
+__exportStar(require("./SetAnswerTextUC"), exports);
+__exportStar(require("./SubmitQuestionAnswerUC"), exports);
+__exportStar(require("./ToggleQuestionAnswerIsCorrect"), exports);

package/lib/AppObjectComponents/SceneRoot/Controllers/DoubleTapToFocus.d.ts

@@ -0,0 +1,20 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { TouchController, TouchInputEvent } from "../../TouchController";
+export declare class DoubleTapToFocus extends AppObjectController implements TouchController {
+    static readonly type = "DoubleTapToFocus";
+    readonly focusDurationMS = 500;
+    readonly tapTimeMS = 300;
+    readonly maxTapDistancePx = 30;
+    private initialTouchPos;
+    private initialTouchTime;
+    private tapCount;
+    private focusOnPixelUC?;
+    allow: (e: TouchInputEvent) => boolean;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    private cancelDoubleTap;
+    private checkForMovement;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/SceneRoot/Controllers/DoubleTapToFocus.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoubleTapToFocus = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const ValueObjects_1 = require("../../../ValueObjects");
+const App_1 = require("../../App");
+const TouchController_1 = require("../../TouchController");
+const FocusOnPixel_1 = require("../UC/FocusOnPixel");
+class DoubleTapToFocus extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, DoubleTapToFocus.type);
+        this.focusDurationMS = 500;
+        this.tapTimeMS = 300;
+        this.maxTapDistancePx = 30;
+        this.initialTouchPos = ValueObjects_1.Vector2.Zero();
+        this.initialTouchTime = 0;
+        this.tapCount = 0;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            if (!this.allow(e)) {
+                this.cancelDoubleTap();
+                return;
+            }
+            if (e.touchCount !== 1) {
+                this.cancelDoubleTap();
+                return;
+            }
+            this.tapCount = this.tapCount + 1;
+            if (this.tapCount === 1) {
+                this.initialTouchPos = e.touchCenter;
+                this.initialTouchTime = Date.now();
+            }
+            else if (this.tapCount === 2) {
+                this.checkForMovement(e.touchCenter);
+            }
+        };
+        this.onTouchMove = (e) => {
+            if (this.tapCount !== 1)
+                return;
+            if (e.touchCount !== 1) {
+                this.cancelDoubleTap();
+                return;
+            }
+            this.checkForMovement(e.touchCenter);
+        };
+        this.onTouchEnd = () => {
+            var _a;
+            if (this.tapCount === 2) {
+                const passedTime = Date.now() - this.initialTouchTime;
+                if (passedTime > this.tapTimeMS) {
+                    this.cancelDoubleTap();
+                    return;
+                }
+                (_a = this.focusOnPixelUC) === null || _a === void 0 ? void 0 : _a.centerOnPixel(this.initialTouchPos);
+                this.tapCount = 0;
+                this.initialTouchTime = 0;
+            }
+        };
+        this.cancelDoubleTap = () => {
+            this.initialTouchTime = 0;
+            this.tapCount = 0;
+        };
+        const appObjects = appObject.appObjectRepo;
+        this.focusOnPixelUC = appObject.getComponent(FocusOnPixel_1.FocusOnPixelUC.type);
+        if (!this.focusOnPixelUC) {
+            App_1.submitWarning("DoubleTapToFocus", "Controller has been added to an App Object that does not have FocusOnPixelUC. Add one first.", appObjects);
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("DoubleTapToFocus", "Unable to find TouchInputEntity", appObjects);
+        }
+    }
+    checkForMovement(currentPixelPos) {
+        const movement = ValueObjects_1.Vector2.Subtract(this.initialTouchPos, currentPixelPos)
+            .magnitued;
+        if (movement > this.maxTapDistancePx) {
+            this.cancelDoubleTap();
+            return;
+        }
+    }
+}
+exports.DoubleTapToFocus = DoubleTapToFocus;
+DoubleTapToFocus.type = "DoubleTapToFocus";

package/lib/AppObjectComponents/SceneRoot/Controllers/MouseClickToFocus.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare class MouseClickToFocus extends AppObjectController implements MouseController {
+    static readonly type = "MouseClickToFocus";
+    private appObjects;
+    private centerOnPixelUI?;
+    allow: (e: MouseInputEvent) => boolean;
+    onClick: (e: MouseInputEvent) => void;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/SceneRoot/Controllers/MouseClickToFocus.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseClickToFocus = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const MouseInput_1 = require("../../MouseInput");
+const CenterSceneRootOnPixelPick_1 = require("../UC/CenterSceneRootOnPixelPick");
+class MouseClickToFocus extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseClickToFocus.type);
+        this.allow = (e) => {
+            return true;
+        };
+        this.onClick = (e) => {
+            var _a;
+            if (this.allow(e)) {
+                (_a = this.centerOnPixelUI) === null || _a === void 0 ? void 0 : _a.centerOnPixel(e.position);
+            }
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.centerOnPixelUI = appObject.getComponent(CenterSceneRootOnPixelPick_1.CenterSceneRootOnPixelPickUC.type);
+        if (!this.centerOnPixelUI) {
+            App_1.submitWarning("MouseClickToFocus", "Controller has been added to an App Object that does not have CenterSceneRootOnPixelPickUC. Add one first.", this.appObjects);
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("MouseClickToFocus", "Unable to find MouseInputEntity", this.appObjects);
+        }
+    }
+}
+exports.MouseClickToFocus = MouseClickToFocus;
+MouseClickToFocus.type = "MouseClickToFocus";

package/lib/AppObjectComponents/SceneRoot/Controllers/MouseDoubleClickToRecenter.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare class MouseDoubleClickToRecenter extends AppObjectController implements MouseController {
+    static readonly type = "MouseDoubleClickToRecenter";
+    protected focusDurationMS: number;
+    private appObjects;
+    private focusUC?;
+    allow: (e: MouseInputEvent) => boolean;
+    onDoubleClick: (e: MouseInputEvent) => void;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/SceneRoot/Controllers/MouseDoubleClickToRecenter.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseDoubleClickToRecenter = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const MouseInput_1 = require("../../MouseInput");
+const FocusOnPixel_1 = require("../UC/FocusOnPixel");
+class MouseDoubleClickToRecenter extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseDoubleClickToRecenter.type);
+        this.focusDurationMS = 500;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onDoubleClick = (e) => {
+            var _a;
+            if (this.allow(e)) {
+                (_a = this.focusUC) === null || _a === void 0 ? void 0 : _a.centerOnPixel(e.position);
+            }
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.focusUC = appObject.getComponent(FocusOnPixel_1.FocusOnPixelUC.type);
+        if (!this.focusUC) {
+            App_1.submitWarning("MouseDoubleClickToRecenter", "Controller has been added to an App Object that does not have FocusOnPixelUC. Add one first.", this.appObjects);
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("MouseDoubleClickToRecenter", "Unable to find MouseInputEntity", this.appObjects);
+        }
+    }
+}
+exports.MouseDoubleClickToRecenter = MouseDoubleClickToRecenter;
+MouseDoubleClickToRecenter.type = "MouseDoubleClickToRecenter";

package/lib/AppObjectComponents/SceneRoot/Controllers/MouseOrbit.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare class MouseOrbit extends AppObjectController implements MouseController {
+    static readonly type = "MouseOrbit";
+    private isOrbiting;
+    private appObjects;
+    private orbitSceneRoot?;
+    allow: (e: MouseInputEvent) => boolean;
+    onDown: (e: MouseInputEvent) => void;
+    onMove: (e: MouseInputEvent) => void;
+    onUp: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/SceneRoot/Controllers/MouseOrbit.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseOrbit = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const MouseInput_1 = require("../../MouseInput");
+const OrbitSceneRoot_1 = require("../UC/OrbitSceneRoot");
+class MouseOrbit extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseOrbit.type);
+        this.isOrbiting = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onDown = (e) => {
+            this.isOrbiting = false;
+            if (!this.orbitSceneRoot)
+                return;
+            if (!this.allow(e))
+                return;
+            const pixelPosition = e.position;
+            this.orbitSceneRoot.initializeOrbit(pixelPosition);
+            this.isOrbiting = true;
+        };
+        this.onMove = (e) => {
+            if (!this.orbitSceneRoot)
+                return;
+            if (!this.isOrbiting)
+                return;
+            const currentPixelPos = e.position;
+            this.orbitSceneRoot.doOrbit(currentPixelPos);
+        };
+        this.onUp = () => {
+            if (!this.orbitSceneRoot)
+                return;
+            this.orbitSceneRoot.finishOrbit();
+            this.isOrbiting = false;
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.orbitSceneRoot = appObject.getComponent(OrbitSceneRoot_1.OrbitSceneRootUC.type);
+        if (!this.orbitSceneRoot) {
+            App_1.submitWarning("MouseOrbit", "Controller has been added to an App Object that does not have OrbitSceneRootUC. Add one first.", this.appObjects);
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("MouseOrbit ", "Unable to find MouseInputEntity", this.appObjects);
+        }
+    }
+}
+exports.MouseOrbit = MouseOrbit;
+MouseOrbit.type = "MouseOrbit";

package/lib/AppObjectComponents/SceneRoot/Controllers/MousePan.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare class MousePan extends AppObjectController implements MouseController {
+    static readonly type = "MousePan";
+    private doPan;
+    private appObjects;
+    allow: (e: MouseInputEvent) => boolean;
+    private panRootUC?;
+    onDown: (e: MouseInputEvent) => void;
+    onMove: (e: MouseInputEvent) => void;
+    onUp: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/SceneRoot/Controllers/MousePan.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MousePan = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const MouseInput_1 = require("../../MouseInput");
+const PanSceneRoot_1 = require("../UC/PanSceneRoot");
+class MousePan extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MousePan.type);
+        this.doPan = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onDown = (e) => {
+            var _a;
+            this.doPan = false;
+            if (!this.allow(e))
+                return;
+            (_a = this.panRootUC) === null || _a === void 0 ? void 0 : _a.initializePan(e.position);
+            this.doPan = true;
+        };
+        this.onMove = (e) => {
+            var _a;
+            if (!this.doPan)
+                return;
+            (_a = this.panRootUC) === null || _a === void 0 ? void 0 : _a.doPan(e.position);
+        };
+        this.onUp = () => {
+            var _a;
+            this.doPan = false;
+            (_a = this.panRootUC) === null || _a === void 0 ? void 0 : _a.finishPan();
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.panRootUC = appObject.getComponent(PanSceneRoot_1.PanSceneRootUC.type);
+        if (!this.panRootUC) {
+            App_1.submitWarning("MousePan", "Controller has been added to an App Object that does not have PanSceneRootUC. Add one first.", this.appObjects);
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("MousePan ", "Unable to find MouseInputEntity", this.appObjects);
+        }
+    }
+}
+exports.MousePan = MousePan;
+MousePan.type = "MousePan";

package/lib/AppObjectComponents/SceneRoot/Controllers/MouseRoll.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseWheelEvent } from "../../MouseInput";
+export declare class MouseRoll extends AppObjectController implements MouseController {
+    static readonly type = "MouseRoll";
+    private appObjects;
+    private bumpRootScaleUC?;
+    allow: (e: MouseWheelEvent) => boolean;
+    onWheel: (e: MouseWheelEvent) => void;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/SceneRoot/Controllers/MouseRoll.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseRoll = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const MouseInput_1 = require("../../MouseInput");
+const BumpSceneRootScaleAboutPixelPoint_1 = require("../UC/BumpSceneRootScaleAboutPixelPoint");
+class MouseRoll extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseRoll.type);
+        this.allow = (e) => {
+            return true;
+        };
+        this.onWheel = (e) => {
+            if (!this.allow(e))
+                return;
+            if (!this.bumpRootScaleUC) {
+                return;
+            }
+            this.bumpRootScaleUC.bump(e.event.deltaY > 0 ? "OUT" : "IN", e.position);
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.bumpRootScaleUC = appObject.getComponent(BumpSceneRootScaleAboutPixelPoint_1.BumpSceneRootScaleAboutPixelPointUC.type);
+        if (!this.bumpRootScaleUC) {
+            App_1.submitWarning("MouseRoll", "Controller has been added to an App Object that does not have BumpSceneRootScaleAboutPixelPointUC. Add one first.", this.appObjects);
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("MouseRoll ", "Unable to find MouseInputEntity", this.appObjects);
+        }
+    }
+}
+exports.MouseRoll = MouseRoll;
+MouseRoll.type = "MouseRoll";