@vived/app 3.9.1 → 4.0.0

package/lib/Components/TouchController/UC/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("./UpdateTouchInputBound"), exports);

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

@@ -0,0 +1,2 @@
+export * from "./Entities";
+export * from "./UC";

package/lib/Components/TouchController/index.js

@@ -0,0 +1,14 @@
+"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("./Entities"), exports);
+__exportStar(require("./UC"), exports);

package/lib/Components/Transform3D/Entities/Transform3D.d.ts

@@ -0,0 +1,32 @@
+import { AppObject, AppObjectEntity } from "../../../AppObject";
+import { EaseFn } from "../../../Types";
+import { Matrix, Quaternion, Vector3 } from "../../../ValueObjects";
+export interface TransformLerpDTO {
+    durationMS: number;
+    ease: EaseFn;
+    desiredPosition?: Vector3;
+    desiredRotation?: Quaternion;
+    desiredScale?: Vector3;
+    onCompletedCallback?: () => void;
+}
+export declare abstract class Transform3D extends AppObjectEntity {
+    static readonly type = "TRANSFORM_3D";
+    static addIfMissing(appObj: AppObject): Transform3D;
+    static get(appObj: AppObject): Transform3D | undefined;
+    abstract parent: Transform3D | undefined;
+    abstract localMatrix: Matrix;
+    abstract worldMatrix: Matrix;
+    abstract localPosition: Vector3;
+    abstract worldPosition: Vector3;
+    abstract localScale: Vector3;
+    abstract worldScale: Vector3;
+    abstract localRotation: Quaternion;
+    abstract worldRotation: Quaternion;
+    abstract localPointToWorld(point: Vector3): Vector3;
+    abstract worldPointToLocal(point: Vector3): Vector3;
+    abstract localDirectionToWorld(point: Vector3): Vector3;
+    abstract worldDirectionToLocal(point: Vector3): Vector3;
+    abstract lerp(dto: TransformLerpDTO): void;
+    abstract cancelLerp(): void;
+}
+export declare function makeTransform3D(appObject: AppObject): Transform3D;

package/lib/Components/Transform3D/Entities/Transform3D.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTransform3D = exports.Transform3D = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+class Transform3D extends AppObject_1.AppObjectEntity {
+    static addIfMissing(appObj) {
+        const existing = appObj.getComponent(this.type);
+        if (existing) {
+            return existing;
+        }
+        else {
+            return makeTransform3D(appObj);
+        }
+    }
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+}
+exports.Transform3D = Transform3D;
+Transform3D.type = "TRANSFORM_3D";
+function makeTransform3D(appObject) {
+    return new Transform3DImp(appObject);
+}
+exports.makeTransform3D = makeTransform3D;
+class Transform3DImp extends Transform3D {
+    constructor(appObject) {
+        super(appObject, Transform3D.type);
+        this._transformationMatrix = ValueObjects_1.Matrix.Identity();
+        this.localPointToWorld = (point) => {
+            return ValueObjects_1.Vector3.Transform(point, this.worldMatrix);
+        };
+        this.worldPointToLocal = (point) => {
+            const worldInverse = ValueObjects_1.Matrix.Invert(this.worldMatrix);
+            return ValueObjects_1.Vector3.Transform(point, worldInverse);
+        };
+        this.localDirectionToWorld = (point) => {
+            const rotationMatrix = ValueObjects_1.Quaternion.ToRotationMatrix(this.worldRotation);
+            return ValueObjects_1.Vector3.Transform(point, rotationMatrix).unit;
+        };
+        this.worldDirectionToLocal = (point) => {
+            const worldInverse = ValueObjects_1.Matrix.Invert(this.worldMatrix);
+            const rotationMatrix = ValueObjects_1.Quaternion.ToRotationMatrix(worldInverse.rotation);
+            return ValueObjects_1.Vector3.Transform(point, rotationMatrix).unit;
+        };
+        this.chrono = 0;
+        this.lerpDuration = 1;
+        this.lerpEase = (p) => p;
+        this.tickInterval = 10;
+        this.previousTime = 0;
+        this.lerp = (dto) => {
+            const { durationMS: duration, ease, desiredPosition, desiredRotation, desiredScale, onCompletedCallback, } = dto;
+            this.cancelLerp();
+            this.chrono = 0;
+            this.lerpDuration = duration;
+            this.lerpEase = ease;
+            if (duration <= 0) {
+                this.localMatrix = ValueObjects_1.Matrix.Compose(desiredScale !== null && desiredScale !== void 0 ? desiredScale : this.localScale, desiredRotation !== null && desiredRotation !== void 0 ? desiredRotation : this.localRotation, desiredPosition !== null && desiredPosition !== void 0 ? desiredPosition : this.localPosition);
+                return;
+            }
+            if (desiredPosition) {
+                this.lerpPos = [this.localPosition, desiredPosition];
+            }
+            else {
+                this.lerpPos = undefined;
+            }
+            if (desiredRotation) {
+                this.lerpQuat = [this.localRotation, desiredRotation];
+            }
+            else {
+                this.lerpQuat = undefined;
+            }
+            if (desiredScale) {
+                this.lerpScale = [this.localScale, desiredScale];
+            }
+            else {
+                this.lerpScale = undefined;
+            }
+            this.onLerpCompletedCallback = onCompletedCallback;
+            this.previousTime = Date.now();
+            this.interval = setInterval(() => {
+                this.tickLerp();
+            }, this.tickInterval);
+        };
+        this.tickLerp = () => {
+            const currentTime = Date.now();
+            const timeDiff = currentTime - this.previousTime;
+            this.previousTime = currentTime;
+            this.chrono = this.chrono + timeDiff;
+            let nomralizedTime = this.chrono / this.lerpDuration;
+            if (nomralizedTime > 1) {
+                nomralizedTime = 1;
+            }
+            const percent = this.lerpEase(nomralizedTime);
+            let pos = this.localPosition;
+            if (this.lerpPos) {
+                pos = ValueObjects_1.Vector3.Lerp(this.lerpPos[0], this.lerpPos[1], percent);
+            }
+            let rotation = this.localRotation;
+            if (this.lerpQuat) {
+                rotation = ValueObjects_1.Quaternion.Slerp(this.lerpQuat[0], this.lerpQuat[1], percent);
+            }
+            let scale = this.localScale;
+            if (this.lerpScale) {
+                scale = ValueObjects_1.Vector3.Lerp(this.lerpScale[0], this.lerpScale[1], percent);
+            }
+            this._transformationMatrix = ValueObjects_1.Matrix.Compose(scale, rotation, pos);
+            this.notifyOnChange();
+            if (nomralizedTime >= 1 && this.interval) {
+                if (this.onLerpCompletedCallback) {
+                    this.onLerpCompletedCallback();
+                }
+                clearInterval(this.interval);
+                this.interval = undefined;
+            }
+        };
+        this.cancelLerp = () => {
+            if (this.interval) {
+                clearInterval(this.interval);
+                this.interval = undefined;
+            }
+        };
+    }
+    get localMatrix() {
+        return this._transformationMatrix;
+    }
+    set localMatrix(val) {
+        if (ValueObjects_1.Matrix.Close(this._transformationMatrix, val))
+            return;
+        this.cancelLerp();
+        this._transformationMatrix = val;
+        this.notifyOnChange();
+    }
+    get worldMatrix() {
+        if (!this._parent) {
+            return this._transformationMatrix;
+        }
+        else {
+            return ValueObjects_1.Matrix.Multiply(this._parent.worldMatrix, this._transformationMatrix);
+        }
+    }
+    get localPosition() {
+        return this._transformationMatrix.translation;
+    }
+    set localPosition(val) {
+        const currentPos = this._transformationMatrix.translation;
+        if (ValueObjects_1.Vector3.Close(val, currentPos, 0.00001))
+            return;
+        this.cancelLerp();
+        this._transformationMatrix = ValueObjects_1.Matrix.SetMatrixTranslation(this._transformationMatrix, val);
+        this.notifyOnChange();
+    }
+    get worldPosition() {
+        return this.worldMatrix.translation;
+    }
+    set worldPosition(val) {
+        if (!this._parent) {
+            this.localPosition = val;
+        }
+        else {
+            const local = this._parent.worldPointToLocal(val);
+            this.localPosition = local;
+        }
+    }
+    get localRotation() {
+        return this._transformationMatrix.rotation;
+    }
+    set localRotation(val) {
+        const currentRot = this._transformationMatrix.rotation;
+        if (ValueObjects_1.Quaternion.Close(val, currentRot))
+            return;
+        this.cancelLerp();
+        this._transformationMatrix = ValueObjects_1.Matrix.SetMatrixRotation(this._transformationMatrix, val);
+        this.notifyOnChange();
+    }
+    get worldRotation() {
+        return this.worldMatrix.rotation;
+    }
+    set worldRotation(val) {
+        if (!this._parent) {
+            this.localRotation = val;
+        }
+        else {
+            const parentRotation = this._parent.worldRotation;
+            const parentRotationInverse = ValueObjects_1.Quaternion.Inverse(parentRotation);
+            this.localRotation = ValueObjects_1.Quaternion.Multiply(parentRotationInverse, val);
+        }
+    }
+    get localScale() {
+        return this._transformationMatrix.scale;
+    }
+    set localScale(val) {
+        const currentScale = this._transformationMatrix.scale;
+        if (ValueObjects_1.Vector3.Close(val, currentScale, 0.00001))
+            return;
+        this.cancelLerp();
+        this._transformationMatrix = ValueObjects_1.Matrix.SetMatrixScale(this._transformationMatrix, val);
+        this.notifyOnChange();
+    }
+    get worldScale() {
+        return this.worldMatrix.scale;
+    }
+    set worldScale(val) {
+        if (!this._parent) {
+            this.localScale = val;
+        }
+        else {
+            const parentScale = this._parent.worldScale;
+            const x = val.x / parentScale.x;
+            const y = val.y / parentScale.y;
+            const z = val.z / parentScale.z;
+            this.localScale = new ValueObjects_1.Vector3(x, y, z);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(val) {
+        if (this._parent === val)
+            return;
+        const wMatrix = this.worldMatrix;
+        this._parent = val;
+        if (this._parent) {
+            const parentMatrix = this._parent.worldMatrix;
+            const parentMatrixInverse = ValueObjects_1.Matrix.Invert(parentMatrix);
+            this.localMatrix = ValueObjects_1.Matrix.Multiply(parentMatrixInverse, wMatrix);
+        }
+        else {
+            this.localMatrix = wMatrix;
+        }
+        this.notifyOnChange();
+    }
+}

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Transform3D"), exports);

package/lib/Components/Transform3D/PM/CanBeStuckPM.d.ts

@@ -0,0 +1,8 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare abstract class CanBeStuckPM extends AppObjectPM<boolean> {
+    static readonly type = "CanBeStuckPM";
+    static getForID(appObjID: string, appObjects: AppObjectRepo): CanBeStuckPM | undefined;
+}
+export declare function makeCanBeStuckPM(appObject: AppObject): CanBeStuckPM;

package/lib/Components/Transform3D/PM/CanBeStuckPM.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCanBeStuckPM = exports.CanBeStuckPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../Entities/Transform3D");
+class CanBeStuckPM extends AppObjectPM_1.AppObjectPM {
+    static getForID(appObjID, appObjects) {
+        const appObj = appObjects.get(appObjID);
+        if (appObj === undefined) {
+            return undefined;
+        }
+        return appObj.getComponent(CanBeStuckPM.type);
+    }
+}
+exports.CanBeStuckPM = CanBeStuckPM;
+CanBeStuckPM.type = "CanBeStuckPM";
+function makeCanBeStuckPM(appObject) {
+    return new CanBeStuckPMImp(appObject);
+}
+exports.makeCanBeStuckPM = makeCanBeStuckPM;
+class CanBeStuckPMImp extends CanBeStuckPM {
+    constructor(appObject) {
+        super(appObject, CanBeStuckPM.type);
+        this.onTransformChange = () => {
+            if (!this.transform)
+                return;
+            const pos = this.transform.localPosition;
+            const canBeStuck = !ValueObjects_1.Vector3.Close(pos, ValueObjects_1.Vector3.Zero());
+            this.doUpdateView(canBeStuck);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.transform) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onTransformChange);
+            (_b = this.transform) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.transform = Transform3D_1.Transform3D.get(appObject);
+        if (!this.transform) {
+            this.warn("Unable to find Transform3D Entity");
+            return;
+        }
+        else {
+            this.transform.addChangeObserver(this.onTransformChange);
+            this.transform.addOnDisposeObserver(this.dispose);
+            this.onTransformChange();
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

package/lib/Components/Transform3D/PM/Transform3DPM.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { Quaternion, Vector3 } from "../../../ValueObjects";
+export interface Transform3DVM {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+}
+export declare abstract class Transform3DPM extends AppObjectPM<Transform3DVM> {
+    static readonly type = "Transform3DPM";
+    static getForID(appObjID: string, appObjects: AppObjectRepo): Transform3DPM | undefined;
+}
+export declare function makeTransform3DPM(appObject: AppObject): Transform3DPM;

package/lib/Components/Transform3D/PM/Transform3DPM.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTransform3DPM = exports.Transform3DPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../Entities/Transform3D");
+class Transform3DPM extends AppObjectPM_1.AppObjectPM {
+    static getForID(appObjID, appObjects) {
+        const appObj = appObjects.get(appObjID);
+        if (appObj === undefined) {
+            return undefined;
+        }
+        return appObj.getComponent(Transform3DPM.type);
+    }
+}
+exports.Transform3DPM = Transform3DPM;
+Transform3DPM.type = "Transform3DPM";
+function makeTransform3DPM(appObject) {
+    return new Transform3DPMImp(appObject);
+}
+exports.makeTransform3DPM = makeTransform3DPM;
+class Transform3DPMImp extends Transform3DPM {
+    constructor(appObject) {
+        super(appObject, Transform3DPM.type);
+        this.onTransformChange = () => {
+            if (!this.transform)
+                return;
+            const vm = {
+                position: this.transform.localPosition,
+                rotation: this.transform.localRotation,
+                scale: this.transform.localScale,
+            };
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.transform) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onTransformChange);
+            (_b = this.transform) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.transform = Transform3D_1.Transform3D.get(appObject);
+        if (!this.transform) {
+            this.warn("Unable to find Transform3D Entity");
+            return;
+        }
+        else {
+            this.transform.addChangeObserver(this.onTransformChange);
+            this.transform.addOnDisposeObserver(this.dispose);
+            this.onTransformChange();
+        }
+    }
+    vmsAreEqual(a, b) {
+        if (!ValueObjects_1.Vector3.Equal(a.position, b.position))
+            return false;
+        if (!ValueObjects_1.Vector3.Equal(a.scale, b.scale))
+            return false;
+        if (!ValueObjects_1.Quaternion.Equal(a.rotation, b.rotation))
+            return false;
+        return true;
+    }
+    static getForID(appObjID, appObjects) {
+        const appObj = appObjects.get(appObjID);
+        if (appObj === undefined) {
+            return undefined;
+        }
+        return appObj.getComponent(Transform3DPM.type);
+    }
+}
+Transform3DPMImp.defaultTransform3DVM = {
+    position: ValueObjects_1.Vector3.Zero(),
+    rotation: ValueObjects_1.Quaternion.Identity(),
+    scale: ValueObjects_1.Vector3.One(),
+};

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

@@ -0,0 +1,2 @@
+export * from "./CanBeStuckPM";
+export * from "./Transform3DPM";

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

@@ -0,0 +1,14 @@
+"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("./CanBeStuckPM"), exports);
+__exportStar(require("./Transform3DPM"), exports);

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

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { Vector3 } from "../../../ValueObjects";
+export declare abstract class DragTransformUC extends AppObjectUC {
+    static readonly type = "DragTransformUC";
+    static get(appObj: AppObject): DragTransformUC | undefined;
+    abstract initialize(initialPick: Vector3): void;
+    abstract update(pick: Vector3): void;
+    abstract stop(registerUndo?: boolean): void;
+    abstract cancel(): void;
+}
+export declare function makeDragTransformUC(appObject: AppObject): DragTransformUC;

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDragTransformUC = exports.DragTransformUC = 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");
+const MoveTransformUndoRedo_1 = require("./MoveTransformUndoRedo");
+class DragTransformUC extends AppObject_1.AppObjectUC {
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+}
+exports.DragTransformUC = DragTransformUC;
+DragTransformUC.type = "DragTransformUC";
+function makeDragTransformUC(appObject) {
+    return new DragTransformUCImp(appObject);
+}
+exports.makeDragTransformUC = makeDragTransformUC;
+class DragTransformUCImp extends DragTransformUC {
+    constructor(appObject) {
+        super(appObject, DragTransformUC.type);
+        this.initialPos = ValueObjects_1.Vector3.Zero();
+        this.isDragging = false;
+        this.didDrag = false;
+        this.pickOffset = ValueObjects_1.Vector3.Zero();
+        this.initialize = (initialPick) => {
+            this.isDragging = false;
+            this.didDrag = false;
+            if (!this.transform) {
+                return;
+            }
+            const worldPos = this.transform.worldPosition;
+            this.pickOffset = ValueObjects_1.Vector3.Subtract(worldPos, initialPick);
+            this.initialPos = this.transform.localPosition;
+            this.isDragging = true;
+        };
+        this.update = (pick) => {
+            if (!this.isDragging)
+                return;
+            if (!this.transform)
+                return;
+            this.transform.worldPosition = ValueObjects_1.Vector3.Add(pick, this.pickOffset);
+            this.didDrag = true;
+        };
+        this.stop = (registerUndo = false) => {
+            var _a, _b;
+            if (!this.transform)
+                return;
+            this.isDragging = false;
+            if (!this.didDrag)
+                return;
+            (_a = this.dispatchStateChange) === null || _a === void 0 ? void 0 : _a.doDispatch();
+            if (registerUndo) {
+                const undoDTO = {
+                    endPosition: this.transform.localPosition,
+                    endRotation: this.transform.localRotation,
+                    startPosition: this.initialPos,
+                    startRotation: this.transform.localRotation,
+                };
+                (_b = this.undoRedoEntity) === null || _b === void 0 ? void 0 : _b.submitAction(new MoveTransformUndoRedo_1.MoveTransformUndoRedo(undoDTO, this.transform, this.appObject.appObjectRepo));
+            }
+            this.didDrag = false;
+        };
+        this.cancel = () => {
+            if (!this.transform)
+                return;
+            if (!this.isDragging)
+                return;
+            this.transform.localPosition = this.initialPos;
+            this.isDragging = false;
+            this.didDrag = false;
+        };
+        this.dispose = () => {
+            var _a;
+            super.dispose();
+            (_a = this.transform) === null || _a === void 0 ? void 0 : _a.removeOnDisposeObserver(this.dispose);
+        };
+        this.transform = appObject.getComponent(Transform3D_1.Transform3D.type);
+        if (!this.transform) {
+            this.warn("Peel Transform UC has been added to an App Object that does not have a Transform3D. Add a transform 3D before adding the UC");
+            this.dispose();
+            return;
+        }
+        this.transform.addOnDisposeObserver(this.dispose);
+    }
+    get dispatchStateChange() {
+        if (!this._cachedDispatchStateChange) {
+            this._cachedDispatchStateChange = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo);
+            if (!this._cachedDispatchStateChange) {
+                this.warn("Unable to find DispatchStateChangeUC");
+                return;
+            }
+        }
+        return this._cachedDispatchStateChange;
+    }
+    get undoRedoEntity() {
+        if (!this._cachedUndoRedo) {
+            this._cachedUndoRedo = UndoRedo_1.UndoRedoEntity.get(this.appObject.appObjectRepo);
+            if (!this._cachedUndoRedo) {
+                this.warn("Unable to find UndoRedoEntity");
+                return;
+            }
+        }
+        return this._cachedUndoRedo;
+    }
+}

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

@@ -0,0 +1,18 @@
+import { AppObjectRepo } from "../../../AppObject";
+import { Quaternion, Vector3 } from "../../../ValueObjects";
+import { UndoRedoAction } from "../../UndoRedo";
+import { Transform3D } from "../Entities";
+export interface MoveTransformUndoRedoDTO {
+    startPosition: Vector3;
+    endPosition: Vector3;
+    startRotation: Quaternion;
+    endRotation: Quaternion;
+}
+export declare class MoveTransformUndoRedo implements UndoRedoAction {
+    private dto;
+    private transform;
+    private dispatchStateChange?;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(dto: MoveTransformUndoRedoDTO, transform: Transform3D, appObjects: AppObjectRepo);
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveTransformUndoRedo = void 0;
+const ValueObjects_1 = require("../../../ValueObjects");
+const Dispatcher_1 = require("../../Dispatcher");
+const UndoRedo_1 = require("../../UndoRedo");
+class MoveTransformUndoRedo {
+    constructor(dto, transform, appObjects) {
+        this.dto = dto;
+        this.transform = transform;
+        this.undoAction = () => {
+            var _a;
+            this.transform.localPosition = this.dto.startPosition;
+            this.transform.localRotation = this.dto.startRotation;
+            (_a = this.dispatchStateChange) === null || _a === void 0 ? void 0 : _a.doDispatch();
+        };
+        this.redoAction = () => {
+            var _a;
+            this.transform.localPosition = this.dto.endPosition;
+            this.transform.localRotation = this.dto.endRotation;
+            (_a = this.dispatchStateChange) === null || _a === void 0 ? void 0 : _a.doDispatch();
+        };
+        if (ValueObjects_1.Vector3.Close(dto.startPosition, dto.endPosition) &&
+            ValueObjects_1.Quaternion.Close(dto.startRotation, dto.endRotation)) {
+            return;
+        }
+        this.dispatchStateChange = Dispatcher_1.DispatchStateChangeUC.get(appObjects);
+        if (!this.dispatchStateChange) {
+            appObjects.submitWarning("MoveTransformUndoRedo", "Unable to find DispatchStateChangeUC");
+            return;
+        }
+        const undoRedo = UndoRedo_1.UndoRedoEntity.get(appObjects);
+        if (!undoRedo) {
+            appObjects.submitWarning("MoveTransformUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.MoveTransformUndoRedo = MoveTransformUndoRedo;