@vived/app 4.28.2 → 4.30.0

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePanTransformWithStickUC = void 0;
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+const Stickable_1 = require("../Entities/Stickable");
+const TryPickStickTarget_1 = require("./TryPickStickTarget");
+function makePanTransformWithStickUC(appObject) {
+    return new PanTransformWithStickUC(appObject);
+}
+exports.makePanTransformWithStickUC = makePanTransformWithStickUC;
+class PanTransformWithStickUC extends Transform3D_1.PanTransformUCImp {
+    constructor() {
+        super(...arguments);
+        this.isFirstPeel = true;
+        this.initialScale = ValueObjects_1.Vector3.Zero();
+        this.initialRot = ValueObjects_1.Quaternion.Identity();
+        this.initializeRay = (ray) => {
+            var _a;
+            if (!this.transformNode || !this.stickable || !this.pickTargetsUC) {
+                this.error("Missing components");
+                return;
+            }
+            const pick = (_a = this.panPlane.intersectLine(ray)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            const rootPos = this.transformNode.worldPosition;
+            this.pickOffset = ValueObjects_1.Vector3.Subtract(rootPos, pick);
+            this.initialScale = this.transformNode.localScale;
+            this.initialRot = this.transformNode.localRotation;
+            this.isFirstPeel = true;
+            this.hasBeenInitialized = true;
+            this.initialPosition = this.transformNode.localPosition;
+        };
+        this.updateRay = (ray) => {
+            var _a;
+            if (!this.transformNode || !this.stickable || !this.pickTargetsUC) {
+                return;
+            }
+            if (!this.hasBeenInitialized)
+                return;
+            if (!this.enabled)
+                return;
+            const pick = (_a = this.panPlane.intersectLine(ray)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            const wPos = ValueObjects_1.Vector3.Add(pick, this.pickOffset);
+            const clampedPos = this.enforceBoundaries(wPos);
+            this.transformNode.worldPosition = clampedPos;
+            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;
+            }
+        };
+        this.finish = () => {
+            if (!this.stickable) {
+                return;
+            }
+            if (!this.hasBeenInitialized)
+                return;
+            if (!this.enabled)
+                return;
+            const doStick = this.stickable.highlightTarget;
+            this.hasBeenInitialized = false;
+            this.stickable.showStickTarget = false;
+            this.stickable.highlightTarget = false;
+            if (doStick) {
+                this.finishWithStick();
+            }
+            else {
+                this.submitDispatchAndUndo();
+            }
+        };
+        this.cancelPan = () => {
+            this.hasBeenInitialized = false;
+            if (this.stickable) {
+                this.stickable.showStickTarget = false;
+                this.stickable.highlightTarget = false;
+            }
+        };
+    }
+    get stickable() {
+        return this.getCachedLocalComponent(Stickable_1.StickableEntity.type);
+    }
+    get pickTargetsUC() {
+        return this.getCachedLocalComponent(TryPickStickTarget_1.TryPickStickTargetUC.type);
+    }
+    finishWithStick() {
+        var _a;
+        const dispatch = this.dispatchStateChange;
+        const transform = this.transformNode;
+        if (!transform || !dispatch || !this.stickable)
+            return;
+        const startPos = this.initialPosition;
+        const finalPos = this.stickable.stickPosition;
+        const startRot = this.initialRot;
+        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();
+                }
+            });
+        }
+    }
+}

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

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

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStickUC = exports.StickUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const Transform3D_1 = require("../../Transform3D/Entities/Transform3D");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const Stickable_1 = require("../Entities/Stickable");
+class StickUC extends AppObject_1.AppObjectUC {
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects.get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(StickUC.type);
+    }
+}
+exports.StickUC = StickUC;
+StickUC.type = "StickUC";
+function makeStickUC(appObject) {
+    return new StickUCImp(appObject);
+}
+exports.makeStickUC = makeStickUC;
+class StickUCImp extends StickUC {
+    constructor(appObject) {
+        super(appObject, StickUC.type);
+        this.doStick = () => {
+            var _a;
+            const transform = this.transform3D;
+            const dispatch = this.dispatchStateChange;
+            if (!transform || !this.stickEntity || !dispatch) {
+                this.error("Missing Components");
+                return;
+            }
+            if (!this.stickEntity.canBeStuck)
+                return;
+            const startPos = transform.localPosition;
+            const finalPos = this.stickEntity.stickPosition;
+            const startRot = transform.localRotation;
+            const finalRot = this.stickEntity.stickRotation;
+            const startScale = transform.localScale;
+            const finalScale = new ValueObjects_1.Vector3(this.stickEntity.stickScale, this.stickEntity.stickScale, this.stickEntity.stickScale);
+            this.stickEntity.doStick(dispatch);
+            (_a = this.undo) === 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();
+                }
+            });
+        };
+    }
+    get stickEntity() {
+        return this.getCachedLocalComponent(Stickable_1.StickableEntity.type);
+    }
+    get transform3D() {
+        return this.getCachedLocalComponent(Transform3D_1.Transform3D.type);
+    }
+    get dispatchStateChange() {
+        var _a;
+        return (_a = this.getCachedSingleton(DispatchStateChangeUC_1.DispatchStateChangeUC.type)) === null || _a === void 0 ? void 0 : _a.doDispatch;
+    }
+    get undo() {
+        return this.getCachedSingleton(UndoRedoEntity_1.UndoRedoEntity.type);
+    }
+}

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

@@ -0,0 +1,8 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { ParametricLine } from "../../../ValueObjects";
+export declare abstract class TryPickStickTargetUC extends AppObjectUC {
+    static type: string;
+    abstract tryPick(ray: ParametricLine): boolean;
+    static get(id: string, appObjects: AppObjectRepo): TryPickStickTargetUC | undefined;
+}
+export declare function makeTryPickStickTargetUC(appObject: AppObject): TryPickStickTargetUC;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTryPickStickTargetUC = exports.TryPickStickTargetUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+class TryPickStickTargetUC extends AppObject_1.AppObjectUC {
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects
+            .get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(TryPickStickTargetUC.type);
+    }
+}
+exports.TryPickStickTargetUC = TryPickStickTargetUC;
+TryPickStickTargetUC.type = "TryPickStickTargetUC";
+function makeTryPickStickTargetUC(appObject) {
+    return new TryPickStickTargetUCImp(appObject);
+}
+exports.makeTryPickStickTargetUC = makeTryPickStickTargetUC;
+class TryPickStickTargetUCImp extends TryPickStickTargetUC {
+    constructor(appObject) {
+        super(appObject, TryPickStickTargetUC.type);
+        this.tryPick = (pickRay) => {
+            this.warn("Picker needs to be injected");
+            return false;
+        };
+    }
+}

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

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

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTryStickAppObjectUC = exports.TryStickAppObjectUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const UC_1 = require("../../Babylon/UC");
+const StickUC_1 = require("./StickUC");
+class TryStickAppObjectUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(TryStickAppObjectUC.type, appObjects);
+    }
+}
+exports.TryStickAppObjectUC = TryStickAppObjectUC;
+TryStickAppObjectUC.type = "TryStickAppObjectUC";
+function makeTryStickAppObjectUC(appObject) {
+    return new TryStickAppObjectUCImp(appObject);
+}
+exports.makeTryStickAppObjectUC = makeTryStickAppObjectUC;
+class TryStickAppObjectUCImp extends TryStickAppObjectUC {
+    constructor(appObject) {
+        super(appObject, TryStickAppObjectUC.type);
+        this.allow = () => {
+            return true;
+        };
+        this.tryWithPixel = (pixel) => {
+            var _a;
+            if (!this.allow())
+                return;
+            if (!this.pixelPick) {
+                return;
+            }
+            const appObjectID = (_a = this.pixelPick(pixel)) === null || _a === void 0 ? void 0 : _a.appObjectID;
+            if (!appObjectID) {
+                return;
+            }
+            this.stickByID(appObjectID);
+        };
+        this.tryWithRay = (pickRay) => {
+            var _a;
+            if (!this.allow())
+                return;
+            if (!this.rayPick) {
+                return;
+            }
+            const appObjectID = (_a = this.rayPick(pickRay)) === null || _a === void 0 ? void 0 : _a.appObjectID;
+            if (!appObjectID) {
+                return;
+            }
+            this.stickByID(appObjectID);
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get pixelPick() {
+        var _a;
+        return (_a = this.getCachedSingleton(UC_1.ScenePixelPickUC.type)) === null || _a === void 0 ? void 0 : _a.scenePixelPick;
+    }
+    get rayPick() {
+        var _a;
+        return (_a = this.getCachedSingleton(UC_1.SceneRayPickUC.type)) === null || _a === void 0 ? void 0 : _a.sceneRayPick;
+    }
+    stickByID(id) {
+        const appObj = this.appObjects.get(id);
+        if (!appObj) {
+            return;
+        }
+        if (!appObj.hasComponent(StickUC_1.StickUC.type)) {
+            return;
+        }
+        const stickUC = appObj.getComponent(StickUC_1.StickUC.type);
+        if (!stickUC) {
+            return;
+        }
+        stickUC.doStick();
+    }
+}

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

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

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

@@ -0,0 +1,16 @@
+"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("./PanTransformWithStickUC"), exports);
+__exportStar(require("./StickUC"), exports);
+__exportStar(require("./TryPickStickTarget"), exports);
+__exportStar(require("./TryStickAppObjectUC"), exports);

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

@@ -0,0 +1,7 @@
+export * from "./Adapters";
+export * from "./Controllers";
+export * from "./Entities";
+export * from "./Factories";
+export * from "./Mocks";
+export * from "./PMs";
+export * from "./UCs";

package/lib/Components/Stick/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("./Adapters"), exports);
+__exportStar(require("./Controllers"), exports);
+__exportStar(require("./Entities"), exports);
+__exportStar(require("./Factories"), exports);
+__exportStar(require("./Mocks"), exports);
+__exportStar(require("./PMs"), exports);
+__exportStar(require("./UCs"), exports);

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

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

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

package/lib/Components/Stylus/Factories/setupStylus.d.ts

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

package/lib/Components/Stylus/Factories/setupStylus.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupStylus = void 0;
+const Transform3D_1 = require("../../Transform3D");
+const Entity_1 = require("../Entity");
+const PMs_1 = require("../PMs");
+const UCs_1 = require("../UCs");
+function setupStylus(appObjects) {
+    const ao = appObjects.getOrCreate("Stylus");
+    // Entities
+    Entity_1.makeStylusEntity(ao);
+    // UCs
+    UCs_1.makeEmulateStylusUC(ao);
+    // PMs
+    PMs_1.makeStylusColorLengthPM(ao);
+    PMs_1.makeStylusIsInUsePM(ao);
+    Transform3D_1.makeTransform3DPM(ao);
+}
+exports.setupStylus = setupStylus;

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

@@ -1,5 +1,6 @@
 export * from "./Adapters";
 export * from "./Entity";
+export * from "./Factories";
 export * from "./Mocks";
 export * from "./PMs";
 export * from "./UCs";

package/lib/Components/Stylus/index.js

@@ -12,6 +12,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Adapters"), exports);
 __exportStar(require("./Entity"), exports);
+__exportStar(require("./Factories"), exports);
 __exportStar(require("./Mocks"), exports);
 __exportStar(require("./PMs"), exports);
 __exportStar(require("./UCs"), exports);

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

@@ -1,5 +1,7 @@
 import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
-import { ParametricLine, Vector2 } from "../../../ValueObjects";
+import { ParametricLine, ParametricPlane, Vector2, Vector3 } from "../../../ValueObjects";
+import { UndoRedoEntity } from "../../UndoRedo";
+import { Transform3D } from "../Entities";
 export declare abstract class PanTransformUC extends AppObjectUC {
     static readonly type = "PanTransformUC";
     abstract minX?: number;
@@ -18,3 +20,28 @@ export declare abstract class PanTransformUC extends AppObjectUC {
     static get(id: string, appObjects: AppObjectRepo): PanTransformUC | undefined;
 }
 export declare function makePanTransformUC(appObject: AppObject): PanTransformUC;
+export declare class PanTransformUCImp extends PanTransformUC {
+    minX?: number | undefined;
+    maxX?: number | undefined;
+    minY?: number | undefined;
+    maxY?: number | undefined;
+    enabled: boolean;
+    protected panPlane: ParametricPlane;
+    dispatchStateChangeOnComplete: boolean;
+    submitUndoOnComplete: boolean;
+    protected pickOffset: Vector3;
+    protected initialPosition: Vector3;
+    protected hasBeenInitialized: boolean;
+    protected get transformNode(): Transform3D | undefined;
+    protected get undoRedo(): UndoRedoEntity | undefined;
+    protected get dispatchStateChange(): (() => void) | undefined;
+    initializePixel: (initialPixelPos: Vector2) => void;
+    updatePixel: (pixelPosition: Vector2) => void;
+    initializeRay: (ray: ParametricLine) => void;
+    updateRay: (ray: ParametricLine) => void;
+    protected enforceBoundaries(wPos: Vector3): Vector3;
+    finish: () => void;
+    protected submitDispatchAndUndo(): void;
+    cancelPan: () => void;
+    constructor(appObject: AppObject);
+}

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

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makePanTransformUC = exports.PanTransformUC = void 0;
+exports.PanTransformUCImp = exports.makePanTransformUC = exports.PanTransformUC = void 0;
 const AppObject_1 = require("../../../AppObject");
 const ValueObjects_1 = require("../../../ValueObjects");
 const Babylon_1 = require("../../Babylon");
 const Dispatcher_1 = require("../../Dispatcher");
 const UndoRedo_1 = require("../../UndoRedo");
 const Entities_1 = require("../Entities");
-const MoveTransformUndoRedo_1 = require("./MoveTransformUndoRedo");
 class PanTransformUC extends AppObject_1.AppObjectUC {
     static get(id, appObjects) {
         var _a;
@@ -49,7 +48,7 @@ class PanTransformUCImp extends PanTransformUC {
             const rootPos = this.transformNode.worldPosition;
             this.pickOffset = ValueObjects_1.Vector3.Subtract(rootPos, pick);
             this.hasBeenInitialized = true;
-            this.initialPosition = this.transformNode.worldPosition;
+            this.initialPosition = this.transformNode.localPosition;
         };
         this.updateRay = (ray) => {
             var _a;
@@ -60,44 +59,17 @@ class PanTransformUCImp extends PanTransformUC {
             if (!this.enabled)
                 return;
             const pick = (_a = this.panPlane.intersectLine(ray)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
-            let wPos = ValueObjects_1.Vector3.Add(pick, this.pickOffset);
-            if (this.minX !== undefined && wPos.x < this.minX) {
-                wPos = new ValueObjects_1.Vector3(this.minX, wPos.y, wPos.z);
-            }
-            if (this.maxX !== undefined && wPos.x > this.maxX) {
-                wPos = new ValueObjects_1.Vector3(this.maxX, wPos.y, wPos.z);
-            }
-            if (this.minY !== undefined && wPos.y < this.minY) {
-                wPos = new ValueObjects_1.Vector3(wPos.x, this.minY, wPos.z);
-            }
-            if (this.maxY !== undefined && wPos.y > this.maxY) {
-                wPos = new ValueObjects_1.Vector3(wPos.x, this.maxY, wPos.z);
-            }
-            this.transformNode.worldPosition = wPos;
+            const wPos = ValueObjects_1.Vector3.Add(pick, this.pickOffset);
+            const clampedPos = this.enforceBoundaries(wPos);
+            this.transformNode.worldPosition = clampedPos;
         };
         this.finish = () => {
-            var _a, _b;
-            if (!this.transformNode)
-                return;
             if (!this.hasBeenInitialized)
                 return;
             if (!this.enabled)
                 return;
             this.hasBeenInitialized = false;
-            if (ValueObjects_1.Vector3.Equal(this.initialPosition, (_a = this.transformNode) === null || _a === void 0 ? void 0 : _a.worldPosition))
-                return;
-            if (this.dispatchStateChangeOnComplete) {
-                Dispatcher_1.dispatchStateChange(this.appObjects);
-            }
-            if (this.submitUndoOnComplete) {
-                const undoDTO = {
-                    endPosition: this.transformNode.localPosition,
-                    endRotation: this.transformNode.localRotation,
-                    startPosition: this.initialPosition,
-                    startRotation: this.transformNode.localRotation,
-                };
-                (_b = this.undoRedo) === null || _b === void 0 ? void 0 : _b.submitAction(new MoveTransformUndoRedo_1.MoveTransformUndoRedo(undoDTO, this.transformNode, this.appObjects));
-            }
+            this.submitDispatchAndUndo();
         };
         this.cancelPan = () => {
             this.hasBeenInitialized = false;
@@ -109,4 +81,50 @@ class PanTransformUCImp extends PanTransformUC {
     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;
+    }
+    enforceBoundaries(wPos) {
+        let pos = wPos;
+        if (this.minX !== undefined && pos.x < this.minX) {
+            pos = new ValueObjects_1.Vector3(this.minX, pos.y, pos.z);
+        }
+        if (this.maxX !== undefined && pos.x > this.maxX) {
+            pos = new ValueObjects_1.Vector3(this.maxX, pos.y, pos.z);
+        }
+        if (this.minY !== undefined && pos.y < this.minY) {
+            pos = new ValueObjects_1.Vector3(pos.x, this.minY, pos.z);
+        }
+        if (this.maxY !== undefined && pos.y > this.maxY) {
+            pos = new ValueObjects_1.Vector3(pos.x, this.maxY, pos.z);
+        }
+        return pos;
+    }
+    submitDispatchAndUndo() {
+        var _a;
+        const dispatch = this.dispatchStateChange;
+        const transform = this.transformNode;
+        if (!transform || !dispatch)
+            return;
+        if (ValueObjects_1.Vector3.Equal(this.initialPosition, transform.localPosition))
+            return;
+        if (this.dispatchStateChangeOnComplete) {
+            dispatch();
+        }
+        if (this.submitUndoOnComplete) {
+            const redoPos = transform.localPosition;
+            (_a = this.undoRedo) === null || _a === void 0 ? void 0 : _a.submitAction({
+                undoAction: () => {
+                    transform.localPosition = this.initialPosition;
+                    dispatch();
+                },
+                redoAction: () => {
+                    transform.localPosition = redoPos;
+                    dispatch();
+                },
+            });
+        }
+    }
 }
+exports.PanTransformUCImp = PanTransformUCImp;

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

@@ -1,5 +1,6 @@
 import { AppObject, AppObjectUC } from "../../../AppObject";
 import { ParametricLine, Vector2 } from "../../../ValueObjects";
+import { SceneRayPickUC } from "../../Babylon";
 import { PanTransformUC } from "./PanTransformUC";
 export declare abstract class TryPanTransformUC extends AppObjectUC {
     static readonly type = "TryPanTransformUC";
@@ -14,8 +15,8 @@ export declare abstract class TryPanTransformUC extends AppObjectUC {
 export declare function makeTryPanTransformUC(appObject: AppObject): TryPanTransformUC;
 export declare class TryPanTransformUCImp extends TryPanTransformUC {
     protected panUC?: PanTransformUC;
-    private get pixelToRay();
-    private get rayPickUC();
+    protected get pixelToRay(): ((pixelPos: Vector2) => ParametricLine) | undefined;
+    protected get rayPickUC(): SceneRayPickUC | undefined;
     allow: () => boolean;
     tryWithPixel: (pixel: Vector2) => boolean;
     moveWithPixel: (pixel: Vector2) => void;

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

@@ -5,6 +5,5 @@ export * from "./PanTransformUC";
 export * from "./PinchTransform";
 export * from "./RayPanScaleTransform";
 export * from "./ScaleTransform";
-export * from "./StickTransformUC";
 export * from "./StylusMoveTransformUC";
 export * from "./TryPanTransformUC";

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

@@ -17,6 +17,5 @@ __exportStar(require("./PanTransformUC"), exports);
 __exportStar(require("./PinchTransform"), exports);
 __exportStar(require("./RayPanScaleTransform"), exports);
 __exportStar(require("./ScaleTransform"), exports);
-__exportStar(require("./StickTransformUC"), exports);
 __exportStar(require("./StylusMoveTransformUC"), exports);
 __exportStar(require("./TryPanTransformUC"), exports);