@vived/app 4.34.2 → 4.34.4

package/lib/Components/Callouts/Factories/setupCallouts.js

@@ -19,8 +19,8 @@ function setupCallouts(appObjects) {
     // Controllers
     new Controller_1.MouseAddCalloutMC(calloutsAO);
     new Controller_1.TouchAddCalloutTC(calloutsAO);
-    new Transform3D_1.TryMousePanTransformMC(calloutsAO);
-    new Transform3D_1.TryTouchPanTransformTC(calloutsAO);
+    new Transform3D_1.MousePanTransformMC(calloutsAO);
+    new Transform3D_1.TouchPanTransformTC(calloutsAO);
     // Setup Tool
     const toolRepo = Tools_1.ToolRepository.get(appObjects);
     if (!toolRepo) {

package/lib/Components/ChannelModel/Factories/setupChannelModels.js

@@ -18,8 +18,8 @@ function setupChannelModels(appObjects) {
     PMs_1.makeActiveModelPM(appObj);
     PMs_1.makeActiveModelObjectListPM(appObj);
     // Controllers
-    new Transform3D_1.TryMousePanTransformMC(appObj);
-    new Transform3D_1.TryTouchPanTransformTC(appObj);
+    new Transform3D_1.MousePanTransformMC(appObj);
+    new Transform3D_1.TouchPanTransformTC(appObj);
     repo.channelModelFactory = channelModelFactory_1.makeChannelModelFactory(appObjects);
 }
 exports.setupChannelModels = setupChannelModels;

package/lib/Components/Selection/UC/HoverAppObjectUC.js

@@ -4,6 +4,7 @@ exports.makeHoverAppObject = exports.HoverAppObjectUC = void 0;
 const AppObject_1 = require("../../../AppObject");
 const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
 const Babylon_1 = require("../../Babylon");
+const BaseApp_1 = require("../../BaseApp");
 const Selectable_1 = require("../Entities/Selectable");
 const Selection_1 = require("../Entities/Selection");
 class HoverAppObjectUC extends AppObjectUC_1.AppObjectUC {
@@ -21,10 +22,16 @@ class HoverAppObjectUCImp extends HoverAppObjectUC {
     constructor(appObject) {
         super(appObject, HoverAppObjectUC.type);
         this.allowHover = () => {
-            return true;
+            if (!this.baseApp) {
+                return false;
+            }
+            return this.baseApp.isAuthoring;
         };
         this.allowTryHover = () => {
-            return true;
+            if (!this.baseApp) {
+                return false;
+            }
+            return this.baseApp.isAuthoring;
         };
         this.tryHoverAppObject = (ray) => {
             if (!this.selection)
@@ -60,4 +67,7 @@ class HoverAppObjectUCImp extends HoverAppObjectUC {
     get selection() {
         return this.getCachedSingleton(Selection_1.Selection.type);
     }
+    get baseApp() {
+        return this.getCachedSingleton(BaseApp_1.BaseAppState.type);
+    }
 }

package/lib/Components/Selection/UC/PressAppObjectUC.js

@@ -4,6 +4,7 @@ exports.makePressAppObject = exports.PressAppObjectUC = void 0;
 const AppObject_1 = require("../../../AppObject");
 const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
 const Babylon_1 = require("../../Babylon");
+const BaseApp_1 = require("../../BaseApp");
 const Selectable_1 = require("../Entities/Selectable");
 const Selection_1 = require("../Entities/Selection");
 class PressAppObjectUC extends AppObjectUC_1.AppObjectUC {
@@ -21,10 +22,16 @@ class PressAppObjectUCImp extends PressAppObjectUC {
     constructor(appObject) {
         super(appObject, PressAppObjectUC.type);
         this.allowPress = () => {
-            return true;
+            if (!this.baseApp) {
+                return false;
+            }
+            return this.baseApp.isAuthoring;
         };
         this.allowTryPress = () => {
-            return true;
+            if (!this.baseApp) {
+                return false;
+            }
+            return this.baseApp.isAuthoring;
         };
         this.tryPressAppObject = (ray) => {
             if (!this.selection)
@@ -61,4 +68,7 @@ class PressAppObjectUCImp extends PressAppObjectUC {
     get selection() {
         return this.getCachedSingleton(Selection_1.Selection.type);
     }
+    get baseApp() {
+        return this.getCachedSingleton(BaseApp_1.BaseAppState.type);
+    }
 }

package/lib/Components/Selection/UC/SelectAppObjectUC.js

@@ -4,6 +4,7 @@ exports.makeSelectAppObject = exports.SelectAppObjectUC = void 0;
 const AppObject_1 = require("../../../AppObject");
 const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
 const Babylon_1 = require("../../Babylon");
+const BaseApp_1 = require("../../BaseApp");
 const Selectable_1 = require("../Entities/Selectable");
 const Selection_1 = require("../Entities/Selection");
 class SelectAppObjectUC extends AppObjectUC_1.AppObjectUC {
@@ -21,10 +22,16 @@ class SelectAppObjectUCImp extends SelectAppObjectUC {
     constructor(appObject) {
         super(appObject, SelectAppObjectUC.type);
         this.allowSelect = () => {
-            return true;
+            if (!this.baseApp) {
+                return false;
+            }
+            return this.baseApp.isAuthoring;
         };
         this.allowTrySelect = () => {
-            return true;
+            if (!this.baseApp) {
+                return false;
+            }
+            return this.baseApp.isAuthoring;
         };
         this.trySelectAppObject = (ray) => {
             if (!this.selection)
@@ -60,4 +67,7 @@ class SelectAppObjectUCImp extends SelectAppObjectUC {
     get selection() {
         return this.getCachedSingleton(Selection_1.Selection.type);
     }
+    get baseApp() {
+        return this.getCachedSingleton(BaseApp_1.BaseAppState.type);
+    }
 }

package/lib/Components/Stick/UCs/MoveTransformWithStickUC.d.ts

@@ -0,0 +1,3 @@
+import { AppObject } from "../../../AppObject";
+import { MoveTransformUC } from "../../Transform3D";
+export declare function makeMoveTransformWithStickUC(appObject: AppObject): MoveTransformUC;

package/lib/Components/Stick/UCs/MoveTransformWithStickUC.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMoveTransformWithStickUC = void 0;
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+const Stickable_1 = require("../Entities/Stickable");
+const TryPickStickTarget_1 = require("./TryPickStickTarget");
+function makeMoveTransformWithStickUC(appObject) {
+    return new MoveTransformWithStickUC(appObject);
+}
+exports.makeMoveTransformWithStickUC = makeMoveTransformWithStickUC;
+class MoveTransformWithStickUC extends Transform3D_1.MoveTransformUCImp {
+    constructor() {
+        super(...arguments);
+        this.isFirstPeel = true;
+        this.initialScale = ValueObjects_1.Vector3.Zero();
+    }
+    get stickable() {
+        return this.getCachedLocalComponent(Stickable_1.StickableEntity.type);
+    }
+    get pickTargetsUC() {
+        return this.getCachedLocalComponent(TryPickStickTarget_1.TryPickStickTargetUC.type);
+    }
+    initialize(helper) {
+        if (!this.transform)
+            return;
+        super.initialize(helper);
+        this.initialScale = this.transform.localScale;
+        this.isFirstPeel = true;
+    }
+    update(helper, ray) {
+        super.update(helper, ray);
+        if (!this.pickTargetsUC || !this.stickable) {
+            return;
+        }
+        const isHitStickTarget = this.pickTargetsUC.tryPick(ray);
+        if (isHitStickTarget) {
+            if (this.isFirstPeel) {
+                this.stickable.showStickTarget = false;
+                this.stickable.highlightTarget = false;
+            }
+            else {
+                this.stickable.showStickTarget = true;
+                this.stickable.highlightTarget = true;
+            }
+        }
+        else {
+            this.stickable.showStickTarget = true;
+            this.stickable.highlightTarget = false;
+            this.isFirstPeel = false;
+        }
+    }
+    finish() {
+        super.finish();
+        if (!this.stickable) {
+            return;
+        }
+        const doStick = this.stickable.highlightTarget;
+        this.stickable.showStickTarget = false;
+        this.stickable.highlightTarget = false;
+        if (doStick) {
+            this.finishWithStick();
+        }
+        else {
+            this.submitDispatchAndUndo();
+        }
+    }
+    finishWithStick() {
+        var _a;
+        const dispatch = this.dispatchStateChange;
+        const transform = this.transform;
+        if (!transform || !dispatch || !this.stickable)
+            return;
+        const startPos = this.initialPos;
+        const finalPos = this.stickable.stickPosition;
+        const startRot = this.initialRotation;
+        const finalRot = this.stickable.stickRotation;
+        const startScale = this.initialScale;
+        const finalScale = new ValueObjects_1.Vector3(this.stickable.stickScale, this.stickable.stickScale, this.stickable.stickScale);
+        if (this.dispatchStateChangeOnComplete) {
+            this.stickable.doStick(dispatch);
+        }
+        else {
+            this.stickable.doStick();
+        }
+        if (this.submitUndoOnComplete) {
+            (_a = this.undoRedo) === null || _a === void 0 ? void 0 : _a.submitAction({
+                undoAction: () => {
+                    transform.localPosition = startPos;
+                    transform.localRotation = startRot;
+                    transform.localScale = startScale;
+                    dispatch();
+                },
+                redoAction: () => {
+                    transform.localPosition = finalPos;
+                    transform.localRotation = finalRot;
+                    transform.localScale = finalScale;
+                    dispatch();
+                },
+            });
+        }
+    }
+    cancel() {
+        super.cancel();
+        if (this.stickable) {
+            this.stickable.showStickTarget = false;
+            this.stickable.highlightTarget = false;
+        }
+    }
+}

package/lib/Components/Stick/UCs/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./MoveTransformWithStickUC";
 export * from "./PanTransformWithStickUC";
 export * from "./StickUC";
 export * from "./TryPickStickTarget";

package/lib/Components/Stick/UCs/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("./MoveTransformWithStickUC"), exports);
 __exportStar(require("./PanTransformWithStickUC"), exports);
 __exportStar(require("./StickUC"), exports);
 __exportStar(require("./TryPickStickTarget"), exports);

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

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { MouseController, MouseInputEvent } from "../../../MouseInput";
+export declare class MousePanTransformMC extends AppObjectController implements MouseController {
+    static readonly type = "MousePanTransformMC";
+    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);
+}

package/lib/Components/Transform3D/Controllers/Mouse/MousePanTransformMC.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MousePanTransformMC = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const MouseInput_1 = require("../../../MouseInput");
+const TryPanTransformUC_1 = require("../../UC/TryPanTransformUC");
+class MousePanTransformMC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        var _a;
+        super(appObject, MousePanTransformMC.type);
+        this.allow = (e) => {
+            if (e.button !== 0)
+                return false;
+            return true;
+        };
+        this.isDragging = false;
+        this.onDown = (e) => {
+            var _a, _b, _c;
+            if (this.isDragging) {
+                (_a = this.tryScreenDragUC) === null || _a === void 0 ? void 0 : _a.cancel();
+                this.isDragging = false;
+            }
+            if (!this.allow(e)) {
+                return;
+            }
+            this.isDragging = (_c = (_b = this.tryScreenDragUC) === null || _b === void 0 ? void 0 : _b.tryWithPixel(e.position)) !== null && _c !== void 0 ? _c : false;
+        };
+        this.onMove = (e) => {
+            var _a;
+            if (!this.isDragging)
+                return;
+            (_a = this.tryScreenDragUC) === null || _a === void 0 ? void 0 : _a.moveWithPixel(e.position);
+        };
+        this.onUp = () => {
+            var _a;
+            if (!this.isDragging)
+                return;
+            (_a = this.tryScreenDragUC) === null || _a === void 0 ? void 0 : _a.stop();
+            this.isDragging = false;
+        };
+        (_a = this.mouseInput) === null || _a === void 0 ? void 0 : _a.registerController(this);
+    }
+    get mouseInput() {
+        return this.getCachedSingleton(MouseInput_1.MouseInputEntity.type);
+    }
+    get tryScreenDragUC() {
+        return this.getCachedLocalComponent(TryPanTransformUC_1.TryPanTransformUC.type);
+    }
+}
+exports.MousePanTransformMC = MousePanTransformMC;
+MousePanTransformMC.type = "MousePanTransformMC";

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

@@ -1,4 +1,4 @@
 export * from "./DragScaleTransformMC";
 export * from "./PanTransformMC";
 export * from "./RollScaleTransformMC";
-export * from "./TryMousePanTransformMC";
+export * from "./MousePanTransformMC";

package/lib/Components/Transform3D/Controllers/Mouse/index.js

@@ -13,4 +13,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./DragScaleTransformMC"), exports);
 __exportStar(require("./PanTransformMC"), exports);
 __exportStar(require("./RollScaleTransformMC"), exports);
-__exportStar(require("./TryMousePanTransformMC"), exports);
+__exportStar(require("./MousePanTransformMC"), exports);

package/lib/Components/Transform3D/Controllers/Stylus/MoveTransformSC.d.ts

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { StylusController } from "../../../Stylus";
+export declare class MoveTransformSC extends AppObjectController implements StylusController {
+    static readonly type = "MoveTransformSC";
+    private get stylus();
+    private get tryMoveUC();
+    private doUpdate;
+    allow: (button: number) => boolean;
+    onButtonDown: (button: number) => void;
+    onStylusMove: () => void;
+    onButtonUp: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Transform3D/Controllers/Stylus/MoveTransformSC.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveTransformSC = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const Stylus_1 = require("../../../Stylus");
+const UC_1 = require("../../UC");
+class MoveTransformSC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        var _a;
+        super(appObject, MoveTransformSC.type);
+        this.doUpdate = false;
+        this.allow = (button) => {
+            if (button === 0)
+                return true;
+            return false;
+        };
+        this.onButtonDown = (button) => {
+            this.doUpdate = false;
+            if (!this.stylus || !this.tryMoveUC)
+                return;
+            if (!this.allow(button))
+                return;
+            this.doUpdate = this.tryMoveUC.tryWithRay(this.stylus.pickRay);
+        };
+        this.onStylusMove = () => {
+            if (!this.stylus || !this.tryMoveUC)
+                return;
+            if (!this.doUpdate)
+                return;
+            this.tryMoveUC.moveWithRay(this.stylus.pickRay);
+        };
+        this.onButtonUp = () => {
+            if (!this.doUpdate)
+                return;
+            this.doUpdate = false;
+            if (!this.tryMoveUC)
+                return;
+            this.tryMoveUC.stop();
+        };
+        (_a = this.stylus) === null || _a === void 0 ? void 0 : _a.registerController(this);
+    }
+    get stylus() {
+        return this.getCachedSingleton(Stylus_1.StylusEntity.type);
+    }
+    get tryMoveUC() {
+        return this.getCachedLocalComponent(UC_1.TryMoveTransformUC.type);
+    }
+}
+exports.MoveTransformSC = MoveTransformSC;
+MoveTransformSC.type = "MoveTransformSC";

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

@@ -1,3 +1,4 @@
+export * from "./MoveTransformSC";
 export * from "./PanScaleTransformSC";
 export * from "./PanTransformSC";
 export * from "./ScaleTransformSC";

package/lib/Components/Transform3D/Controllers/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("./MoveTransformSC"), exports);
 __exportStar(require("./PanScaleTransformSC"), exports);
 __exportStar(require("./PanTransformSC"), exports);
 __exportStar(require("./ScaleTransformSC"), exports);

package/lib/Components/Transform3D/Controllers/Touch/TouchPanTransformTC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { TouchController, TouchInputEvent } from "../../../TouchController";
+export declare class TouchPanTransformTC extends AppObjectController implements TouchController {
+    static readonly type = "TouchPanTransformTC";
+    allow: (e: TouchInputEvent) => boolean;
+    private get tryScreenDragUC();
+    private isDragging;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Transform3D/Controllers/Touch/TouchPanTransformTC.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TouchPanTransformTC = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const TouchController_1 = require("../../../TouchController");
+const TryPanTransformUC_1 = require("../../UC/TryPanTransformUC");
+class TouchPanTransformTC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, TouchPanTransformTC.type);
+        this.allow = (e) => {
+            if (e.touches.length !== 1)
+                return false;
+            return true;
+        };
+        this.isDragging = false;
+        this.onTouchStart = (e) => {
+            var _a;
+            if (this.isDragging) {
+                (_a = this.tryScreenDragUC) === null || _a === void 0 ? void 0 : _a.cancel();
+                this.isDragging = false;
+            }
+            if (!this.tryScreenDragUC)
+                return;
+            if (!this.allow(e))
+                return;
+            const position = e.touches[0].position;
+            this.isDragging = this.tryScreenDragUC.tryWithPixel(position);
+        };
+        this.onTouchMove = (e) => {
+            if (!this.tryScreenDragUC)
+                return;
+            if (!this.isDragging)
+                return;
+            const position = e.touches[0].position;
+            this.tryScreenDragUC.moveWithPixel(position);
+        };
+        this.onTouchEnd = () => {
+            if (!this.tryScreenDragUC)
+                return;
+            if (!this.isDragging)
+                return;
+            this.tryScreenDragUC.stop();
+            this.isDragging = false;
+        };
+        const touchInput = TouchController_1.TouchInputEntity.get(this.appObjects);
+        touchInput === null || touchInput === void 0 ? void 0 : touchInput.registerController(this);
+    }
+    get tryScreenDragUC() {
+        return this.getCachedLocalComponent(TryPanTransformUC_1.TryPanTransformUC.type);
+    }
+}
+exports.TouchPanTransformTC = TouchPanTransformTC;
+TouchPanTransformTC.type = "TouchPanTransformTC";

package/lib/Components/Transform3D/Controllers/Touch/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./DragScaleTransformTC";
 export * from "./PanTransformTC";
 export * from "./PinchTransformTC";
-export * from "./TryTouchPanTransformTC";
+export * from "./TouchPanTransformTC";

package/lib/Components/Transform3D/Controllers/Touch/index.js

@@ -13,4 +13,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./DragScaleTransformTC"), exports);
 __exportStar(require("./PanTransformTC"), exports);
 __exportStar(require("./PinchTransformTC"), exports);
-__exportStar(require("./TryTouchPanTransformTC"), exports);
+__exportStar(require("./TouchPanTransformTC"), exports);

package/lib/Components/Transform3D/Mocks/MockMoveTransformUC.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { MoveTransformUC } from "../UC";
+export declare class MockMoveTransformUC extends MoveTransformUC {
+    dispatchStateChangeOnComplete: boolean;
+    submitUndoOnComplete: boolean;
+    initialize: jest.Mock<any, any>;
+    update: jest.Mock<any, any>;
+    finish: jest.Mock<any, any>;
+    cancel: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Transform3D/Mocks/MockMoveTransformUC.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockMoveTransformUC = void 0;
+const UC_1 = require("../UC");
+class MockMoveTransformUC extends UC_1.MoveTransformUC {
+    constructor(appObject) {
+        super(appObject, UC_1.MoveTransformUC.type);
+        this.dispatchStateChangeOnComplete = true;
+        this.submitUndoOnComplete = true;
+        this.initialize = jest.fn();
+        this.update = jest.fn();
+        this.finish = jest.fn();
+        this.cancel = jest.fn();
+    }
+}
+exports.MockMoveTransformUC = MockMoveTransformUC;

package/lib/Components/Transform3D/Mocks/MockTryMoveTransformUC.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { TryMoveTransformUC } from "../UC/TryMoveTransformUC";
+export declare class MockTryMoveTransformUC extends TryMoveTransformUC {
+    allow: jest.Mock<any, any>;
+    tryWithRay: jest.Mock<any, any>;
+    moveWithRay: jest.Mock<any, any>;
+    stop: jest.Mock<any, any>;
+    cancel: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Transform3D/Mocks/MockTryMoveTransformUC.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockTryMoveTransformUC = void 0;
+const TryMoveTransformUC_1 = require("../UC/TryMoveTransformUC");
+class MockTryMoveTransformUC extends TryMoveTransformUC_1.TryMoveTransformUC {
+    constructor(appObject) {
+        super(appObject, TryMoveTransformUC_1.TryMoveTransformUC.type);
+        this.allow = jest.fn();
+        this.tryWithRay = jest.fn();
+        this.moveWithRay = jest.fn();
+        this.stop = jest.fn();
+        this.cancel = jest.fn();
+    }
+}
+exports.MockTryMoveTransformUC = MockTryMoveTransformUC;

package/lib/Components/Transform3D/UC/MoveTransformUC.d.ts

@@ -0,0 +1,32 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { ParametricLine, Quaternion, Vector3 } from "../../../ValueObjects";
+import { UndoRedoEntity } from "../../UndoRedo";
+import { Transform3D } from "../Entities/Transform3D";
+export declare abstract class MoveTransformUC extends AppObjectUC {
+    static readonly type = "MoveTransformUC";
+    abstract dispatchStateChangeOnComplete: boolean;
+    abstract submitUndoOnComplete: boolean;
+    abstract initialize(helper: Transform3D): void;
+    abstract update(helper: Transform3D, ray: ParametricLine): void;
+    abstract finish(): void;
+    abstract cancel(): void;
+    static get(id: string, appObjects: AppObjectRepo): MoveTransformUC | undefined;
+}
+export declare function makeMoveTransform(appObject: AppObject): MoveTransformUC;
+export declare class MoveTransformUCImp extends MoveTransformUC {
+    dispatchStateChangeOnComplete: boolean;
+    submitUndoOnComplete: boolean;
+    protected get transform(): Transform3D | undefined;
+    protected get undoRedo(): UndoRedoEntity | undefined;
+    protected get dispatchStateChange(): (() => void) | undefined;
+    protected initialPos: Vector3;
+    protected initialRotation: Quaternion;
+    protected isDragging: boolean;
+    protected didDrag: boolean;
+    initialize(helper: Transform3D): void;
+    update(helper: Transform3D, ray: ParametricLine): void;
+    finish(): void;
+    cancel(): void;
+    protected submitDispatchAndUndo(): void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Transform3D/UC/MoveTransformUC.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveTransformUCImp = exports.makeMoveTransform = exports.MoveTransformUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Dispatcher_1 = require("../../Dispatcher");
+const UndoRedo_1 = require("../../UndoRedo");
+const Transform3D_1 = require("../Entities/Transform3D");
+class MoveTransformUC extends AppObject_1.AppObjectUC {
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects
+            .get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(MoveTransformUC.type);
+    }
+}
+exports.MoveTransformUC = MoveTransformUC;
+MoveTransformUC.type = "MoveTransformUC";
+function makeMoveTransform(appObject) {
+    return new MoveTransformUCImp(appObject);
+}
+exports.makeMoveTransform = makeMoveTransform;
+class MoveTransformUCImp extends MoveTransformUC {
+    constructor(appObject) {
+        super(appObject, MoveTransformUC.type);
+        this.dispatchStateChangeOnComplete = true;
+        this.submitUndoOnComplete = true;
+        this.initialPos = ValueObjects_1.Vector3.Zero();
+        this.initialRotation = ValueObjects_1.Quaternion.Identity();
+        this.isDragging = false;
+        this.didDrag = false;
+    }
+    get transform() {
+        return this.getCachedLocalComponent(Transform3D_1.Transform3D.type);
+    }
+    get undoRedo() {
+        return this.getCachedSingleton(UndoRedo_1.UndoRedoEntity.type);
+    }
+    get dispatchStateChange() {
+        var _a;
+        return (_a = this.getCachedSingleton(Dispatcher_1.DispatchStateChangeUC.type)) === null || _a === void 0 ? void 0 : _a.doDispatch;
+    }
+    initialize(helper) {
+        this.isDragging = false;
+        this.didDrag = false;
+        if (!this.transform) {
+            return;
+        }
+        helper.worldPosition = this.transform.worldPosition;
+        helper.worldRotation = this.transform.worldRotation;
+        this.initialPos = this.transform.localPosition;
+        this.initialRotation = this.transform.localRotation;
+        this.isDragging = true;
+    }
+    ;
+    update(helper, ray) {
+        if (!this.isDragging)
+            return;
+        if (!this.transform)
+            return;
+        this.transform.worldRotation = helper.worldRotation;
+        this.transform.worldPosition = helper.worldPosition;
+        this.didDrag = true;
+    }
+    ;
+    finish() {
+        if (!this.transform)
+            return;
+        this.isDragging = false;
+        if (!this.didDrag)
+            return;
+        this.submitDispatchAndUndo();
+        this.didDrag = false;
+    }
+    ;
+    cancel() {
+        if (!this.transform)
+            return;
+        if (!this.isDragging)
+            return;
+        this.isDragging = false;
+        this.didDrag = false;
+    }
+    ;
+    submitDispatchAndUndo() {
+        var _a;
+        const dispatch = this.dispatchStateChange;
+        const transform = this.transform;
+        if (!transform || !dispatch)
+            return;
+        if (ValueObjects_1.Vector3.Equal(this.initialPos, transform.localPosition) &&
+            ValueObjects_1.Quaternion.Equal(this.initialRotation, transform.localRotation))
+            return;
+        if (this.dispatchStateChangeOnComplete) {
+            dispatch();
+        }
+        if (this.submitUndoOnComplete) {
+            const redoPos = transform.localPosition;
+            const redoRot = transform.localRotation;
+            (_a = this.undoRedo) === null || _a === void 0 ? void 0 : _a.submitAction({
+                undoAction: () => {
+                    transform.localPosition = this.initialPos;
+                    transform.localRotation = this.initialRotation;
+                    dispatch();
+                },
+                redoAction: () => {
+                    transform.localPosition = redoPos;
+                    transform.localRotation = redoRot;
+                    dispatch();
+                },
+            });
+        }
+    }
+}
+exports.MoveTransformUCImp = MoveTransformUCImp;

package/lib/Components/Transform3D/UC/TryMoveTransformUC.d.ts

@@ -0,0 +1,24 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { ParametricLine } from "../../../ValueObjects";
+import { SceneRayPickUC } from "../../Babylon";
+import { MoveTransformUC } from "./MoveTransformUC";
+export declare abstract class TryMoveTransformUC extends AppObjectUC {
+    static readonly type = "TryMoveTransformUC";
+    abstract allow(): boolean;
+    abstract tryWithRay(ray: ParametricLine): boolean;
+    abstract moveWithRay(ray: ParametricLine): void;
+    abstract stop(): void;
+    abstract cancel(): void;
+}
+export declare function makeTryMoveTransformUC(appObject: AppObject): TryMoveTransformUC;
+export declare class TryMoveTransformUCImp extends TryMoveTransformUC {
+    protected moveUC?: MoveTransformUC;
+    protected get rayPickUC(): SceneRayPickUC | undefined;
+    private helperTransform;
+    allow: () => boolean;
+    tryWithRay: (pickRay: ParametricLine) => boolean;
+    moveWithRay: (pickRay: ParametricLine) => void;
+    stop: () => void;
+    cancel: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Transform3D/UC/TryMoveTransformUC.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TryMoveTransformUCImp = exports.makeTryMoveTransformUC = exports.TryMoveTransformUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Babylon_1 = require("../../Babylon");
+const Stylus_1 = require("../../Stylus");
+const Entities_1 = require("../Entities");
+const MoveTransformUC_1 = require("./MoveTransformUC");
+class TryMoveTransformUC extends AppObject_1.AppObjectUC {
+}
+exports.TryMoveTransformUC = TryMoveTransformUC;
+TryMoveTransformUC.type = "TryMoveTransformUC";
+function makeTryMoveTransformUC(appObject) {
+    return new TryMoveTransformUCImp(appObject);
+}
+exports.makeTryMoveTransformUC = makeTryMoveTransformUC;
+class TryMoveTransformUCImp extends TryMoveTransformUC {
+    constructor(appObject) {
+        super(appObject, TryMoveTransformUC.type);
+        this.allow = () => {
+            return true;
+        };
+        this.tryWithRay = (pickRay) => {
+            var _a, _b;
+            this.moveUC = undefined;
+            if (!this.allow())
+                return false;
+            const appObjectID = (_b = (_a = this.rayPickUC) === null || _a === void 0 ? void 0 : _a.sceneRayPick(pickRay)) === null || _b === void 0 ? void 0 : _b.appObjectID;
+            if (!appObjectID)
+                return false;
+            this.moveUC = MoveTransformUC_1.MoveTransformUC.get(appObjectID, this.appObjects);
+            if (this.moveUC === undefined) {
+                return false;
+            }
+            this.moveUC.initialize(this.helperTransform);
+            return true;
+        };
+        this.moveWithRay = (pickRay) => {
+            if (!this.moveUC)
+                return;
+            this.moveUC.update(this.helperTransform, pickRay);
+        };
+        this.stop = () => {
+            if (!this.moveUC)
+                return;
+            this.moveUC.finish();
+            this.moveUC = undefined;
+        };
+        this.cancel = () => {
+            if (!this.moveUC)
+                return;
+            this.moveUC.cancel();
+            this.moveUC = undefined;
+        };
+        const helperAO = this.appObjects.getOrCreate(this.appObject.id + "_helper");
+        this.helperTransform = Entities_1.Transform3D.addIfMissing(helperAO);
+        const stylus = Stylus_1.StylusEntity.get(this.appObjects);
+        if (!stylus) {
+            this.error("Unable to find stylus");
+        }
+        else {
+            this.helperTransform.parent = stylus.transform;
+        }
+    }
+    get rayPickUC() {
+        return this.getCachedSingleton(Babylon_1.SceneRayPickUC.type);
+    }
+}
+exports.TryMoveTransformUCImp = TryMoveTransformUCImp;

package/lib/Components/Transform3D/UC/index.d.ts

@@ -1,9 +1,10 @@
 export * from "./BumpTransformScaleAboutPixelPoint";
-export * from "./DragTransformUC";
+export * from "./MoveTransformUC";
 export * from "./MoveTransformUndoRedo";
 export * from "./PanTransformUC";
 export * from "./PinchTransform";
 export * from "./RayPanScaleTransform";
 export * from "./ScaleTransform";
 export * from "./StylusMoveTransformUC";
+export * from "./TryMoveTransformUC";
 export * from "./TryPanTransformUC";

package/lib/Components/Transform3D/UC/index.js

@@ -11,11 +11,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./BumpTransformScaleAboutPixelPoint"), exports);
-__exportStar(require("./DragTransformUC"), exports);
+__exportStar(require("./MoveTransformUC"), exports);
 __exportStar(require("./MoveTransformUndoRedo"), exports);
 __exportStar(require("./PanTransformUC"), exports);
 __exportStar(require("./PinchTransform"), exports);
 __exportStar(require("./RayPanScaleTransform"), exports);
 __exportStar(require("./ScaleTransform"), exports);
 __exportStar(require("./StylusMoveTransformUC"), exports);
+__exportStar(require("./TryMoveTransformUC"), exports);
 __exportStar(require("./TryPanTransformUC"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/app",
-  "version": "4.34.2",
+  "version": "4.34.4",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",