@vived/app 3.9.2 → 4.0.0

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

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { EaseFn } from "../../../Types";
+export declare abstract class StickTransformUC extends AppObjectUC {
+    static readonly type = "StickTransformUC";
+    static get(appObj: AppObject): StickTransformUC | undefined;
+    abstract stickDurationMS: number;
+    abstract easeFn: EaseFn;
+    abstract get canBeStuck(): boolean;
+    abstract stick(onCompleteCallback?: () => void): void;
+}
+export declare function makeStickTransformUC(appObject: AppObject): StickTransformUC;

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStickTransformUC = exports.StickTransformUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../Entities/Transform3D");
+/* TODO
+- Register state change on complete
+- Register Undo on complete based on a flag (optionally)
+- Move stick position and rotation to the Entity
+*/
+class StickTransformUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+}
+exports.StickTransformUC = StickTransformUC;
+StickTransformUC.type = "StickTransformUC";
+function makeStickTransformUC(appObject) {
+    return new StickTransformUCImp(appObject);
+}
+exports.makeStickTransformUC = makeStickTransformUC;
+class StickTransformUCImp extends StickTransformUC {
+    constructor(appObject) {
+        super(appObject, StickTransformUC.type);
+        this.stickDurationMS = 500;
+        this.easeFn = (v) => v;
+        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 canBeStuck() {
+        if (!this.transform)
+            return false;
+        if (!ValueObjects_1.Vector3.Equal(this.transform.localPosition, ValueObjects_1.Vector3.Zero())) {
+            return true;
+        }
+        else if (!ValueObjects_1.Quaternion.Equal(this.transform.localRotation, ValueObjects_1.Quaternion.Identity())) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    stick(onCompleteCallback) {
+        var _a;
+        if (!this.canBeStuck) {
+            if (onCompleteCallback) {
+                onCompleteCallback();
+            }
+            return;
+        }
+        const lerpData = {
+            durationMS: this.stickDurationMS,
+            ease: this.easeFn,
+            desiredPosition: ValueObjects_1.Vector3.Zero(),
+            desiredRotation: ValueObjects_1.Quaternion.Identity(),
+            onCompletedCallback: onCompleteCallback,
+        };
+        (_a = this.transform) === null || _a === void 0 ? void 0 : _a.lerp(lerpData);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class StylusMoveTransformUC extends AppObjectUC {
+    static readonly type = "StylusMoveTransformUC";
+    abstract initialize(): void;
+    abstract move(): void;
+    abstract stop(registerUndo?: boolean): void;
+    static get(appObject: AppObject): StylusMoveTransformUC | undefined;
+}
+export declare function makeStylusMoveTransformUC(appObject: AppObject): StylusMoveTransformUC;

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStylusMoveTransformUC = exports.StylusMoveTransformUC = void 0;
+const __1 = require("..");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Dispatcher_1 = require("../../Dispatcher");
+const UndoRedo_1 = require("../../UndoRedo");
+const ZSpaceEntity_1 = require("../../zSpace/Entities/ZSpaceEntity");
+const MoveTransformUndoRedo_1 = require("./MoveTransformUndoRedo");
+class StylusMoveTransformUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObject) {
+        return appObject.getComponent(StylusMoveTransformUC.type);
+    }
+}
+exports.StylusMoveTransformUC = StylusMoveTransformUC;
+StylusMoveTransformUC.type = "StylusMoveTransformUC";
+function makeStylusMoveTransformUC(appObject) {
+    return new StylusMoveTransformUCImp(appObject);
+}
+exports.makeStylusMoveTransformUC = makeStylusMoveTransformUC;
+class StylusMoveTransformUCImp extends StylusMoveTransformUC {
+    constructor(appObject) {
+        super(appObject, StylusMoveTransformUC.type);
+        this.isMoving = false;
+        this.didMove = false;
+        this.initialPosition = ValueObjects_1.Vector3.Zero();
+        this.initialRotation = ValueObjects_1.Quaternion.Identity();
+        this.move = () => {
+            if (!this.isMoving)
+                return;
+            if (!this.transform)
+                return;
+            if (!this.stylus)
+                return;
+            this.transform.worldPosition = this.stylus.helperTransform.worldPosition;
+            this.transform.worldRotation = this.stylus.helperTransform.worldRotation;
+            this.didMove = true;
+        };
+        this.stop = (registerUndo = false) => {
+            var _a;
+            if (this.didMove) {
+                (_a = this.dispatchStateChange) === null || _a === void 0 ? void 0 : _a.doDispatch();
+                if (registerUndo && this.undoRedoEntity && this.transform) {
+                    const undoDTO = {
+                        endPosition: this.transform.localPosition,
+                        endRotation: this.transform.localRotation,
+                        startPosition: this.initialPosition,
+                        startRotation: this.initialRotation,
+                    };
+                    this.undoRedoEntity.submitAction(new MoveTransformUndoRedo_1.MoveTransformUndoRedo(undoDTO, this.transform, this.appObject.appObjectRepo));
+                }
+            }
+            this.isMoving = false;
+            this.didMove = false;
+        };
+        const appObjects = appObject.appObjectRepo;
+        this.transform = appObject.getComponent(__1.Transform3D.type);
+        if (!this.transform) {
+            this.warn("StylusMoveTransformUCImp has been added to an app object that does not have a Transform3D. Add one first");
+            return;
+        }
+    }
+    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;
+    }
+    get stylus() {
+        if (!this._cachedStylus) {
+            const zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(this.appObject.appObjectRepo);
+            if (!zSpaceEntity) {
+                this.warn("Unable to find ZSpaceEntity");
+                return;
+            }
+            this._cachedStylus = zSpaceEntity.stylus;
+        }
+        return this._cachedStylus;
+    }
+    initialize() {
+        if (!this.transform)
+            return false;
+        if (!this.stylus)
+            return false;
+        this.initialPosition = this.transform.localPosition;
+        this.initialRotation = this.transform.localRotation;
+        this.stylus.helperTransform.worldPosition = this.transform.worldPosition;
+        this.stylus.helperTransform.worldRotation = this.transform.worldRotation;
+        this.isMoving = true;
+        return;
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from "./DragTransformUC";
+export * from "./StickTransformUC";
+export * from "./StylusMoveTransformUC";

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

@@ -0,0 +1,15 @@
+"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("./DragTransformUC"), exports);
+__exportStar(require("./StickTransformUC"), exports);
+__exportStar(require("./StylusMoveTransformUC"), exports);

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

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

package/lib/Components/Transform3D/index.js

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

package/lib/Components/UndoRedo/Controllers/clearUndoStack.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearUndoStack = void 0;
+const UndoRedoEntity_1 = require("../Entities/UndoRedoEntity");
+function clearUndoStack(appObjects) {
+    const undoRedoEntity = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+    if (!undoRedoEntity) {
+        appObjects.submitWarning("clearUndoStack", "Unable to find UndoRedoEntity");
+        return;
+    }
+    undoRedoEntity.clearStack();
+}
+exports.clearUndoStack = clearUndoStack;

package/lib/Components/UndoRedo/Controllers/doRedo.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doRedo = void 0;
+const UndoRedoEntity_1 = require("../Entities/UndoRedoEntity");
+function doRedo(appObjects) {
+    const undoRedoEntity = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+    if (!undoRedoEntity) {
+        appObjects.submitWarning("doRedo", "Unable to find UndoRedoEntity");
+        return;
+    }
+    undoRedoEntity.doRedo();
+}
+exports.doRedo = doRedo;

package/lib/Components/UndoRedo/Controllers/doUndo.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doUndo = void 0;
+const UndoRedoEntity_1 = require("../Entities/UndoRedoEntity");
+function doUndo(appObjects) {
+    const undoRedoEntity = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+    if (!undoRedoEntity) {
+        appObjects.submitWarning("doUndo", "Unable to find UndoRedoEntity");
+        return;
+    }
+    undoRedoEntity.doUndo();
+}
+exports.doUndo = doUndo;

package/lib/Components/UndoRedo/Controllers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./clearUndoStack";
+export * from "./doRedo";
+export * from "./doUndo";

package/lib/Components/UndoRedo/Controllers/index.js

@@ -0,0 +1,15 @@
+"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("./clearUndoStack"), exports);
+__exportStar(require("./doRedo"), exports);
+__exportStar(require("./doUndo"), exports);

package/lib/Components/UndoRedo/Entities/UndoRedoEntity.d.ts

@@ -0,0 +1,29 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+export interface UndoRedoAction {
+    undoAction: () => void;
+    redoAction: () => void;
+}
+export declare abstract class UndoRedoEntity extends AppObjectEntity {
+    static readonly type = "UndoRedoEntity";
+    abstract get hasUndo(): boolean;
+    abstract get hasRedo(): boolean;
+    abstract submitAction: (action: UndoRedoAction) => void;
+    abstract doUndo: () => void;
+    abstract doRedo: () => void;
+    abstract clearStack: () => void;
+    static get: (appObjects: AppObjectRepo) => UndoRedoEntity | undefined;
+}
+export declare function makeUndoRedoEntity(appObject: AppObject): UndoRedoEntityImp;
+export declare function submitUndoRedoAction(action: UndoRedoAction, appObjects: AppObjectRepo): void;
+declare class UndoRedoEntityImp extends UndoRedoEntity {
+    private undoStack;
+    private redoStack;
+    get hasUndo(): boolean;
+    get hasRedo(): boolean;
+    doUndo: () => void;
+    doRedo: () => void;
+    submitAction: (action: UndoRedoAction) => void;
+    clearStack: () => void;
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/Components/UndoRedo/Entities/UndoRedoEntity.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitUndoRedoAction = exports.makeUndoRedoEntity = exports.UndoRedoEntity = void 0;
+const AppObject_1 = require("../../../AppObject");
+class UndoRedoEntity extends AppObject_1.AppObjectEntity {
+}
+exports.UndoRedoEntity = UndoRedoEntity;
+UndoRedoEntity.type = "UndoRedoEntity";
+UndoRedoEntity.get = (appObjects) => AppObject_1.getSingletonComponent(UndoRedoEntity.type, appObjects);
+function makeUndoRedoEntity(appObject) {
+    return new UndoRedoEntityImp(appObject);
+}
+exports.makeUndoRedoEntity = makeUndoRedoEntity;
+function submitUndoRedoAction(action, appObjects) {
+    const undoRedoEntity = UndoRedoEntity.get(appObjects);
+    if (!undoRedoEntity) {
+        appObjects.submitWarning("submitUndoRedoAction", "Unable to find UndoRedoEntity");
+        return;
+    }
+    undoRedoEntity.submitAction(action);
+}
+exports.submitUndoRedoAction = submitUndoRedoAction;
+class UndoRedoEntityImp extends UndoRedoEntity {
+    constructor(appObject) {
+        super(appObject, UndoRedoEntity.type);
+        this.undoStack = [];
+        this.redoStack = [];
+        this.doUndo = () => {
+            const action = this.undoStack.pop();
+            if (!action) {
+                this.warn("Nothing to undo");
+                return;
+            }
+            action.undoAction();
+            this.redoStack.push(action);
+            this.notifyOnChange();
+        };
+        this.doRedo = () => {
+            const action = this.redoStack.pop();
+            if (!action) {
+                this.warn("Nothing to redo");
+                return;
+            }
+            action.redoAction();
+            this.undoStack.push(action);
+            this.notifyOnChange();
+        };
+        this.submitAction = (action) => {
+            this.undoStack.push(action);
+            this.redoStack = [];
+            this.notifyOnChange();
+        };
+        this.clearStack = () => {
+            this.redoStack = [];
+            this.undoStack = [];
+            this.notifyOnChange();
+        };
+    }
+    get hasUndo() {
+        return this.undoStack.length > 0;
+    }
+    get hasRedo() {
+        return this.redoStack.length > 0;
+    }
+}

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

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

package/lib/Components/UndoRedo/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("./UndoRedoEntity"), exports);

package/lib/Components/UndoRedo/Mocks/MockUndoRedo.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { UndoRedoEntity } from "../Entities/UndoRedoEntity";
+export declare class MockUndoRedo extends UndoRedoEntity {
+    get hasUndo(): boolean;
+    get hasRedo(): boolean;
+    submitAction: jest.Mock<any, any>;
+    doUndo: jest.Mock<any, any>;
+    doRedo: jest.Mock<any, any>;
+    clearStack: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/UndoRedo/Mocks/MockUndoRedo.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockUndoRedo = void 0;
+const UndoRedoEntity_1 = require("../Entities/UndoRedoEntity");
+class MockUndoRedo extends UndoRedoEntity_1.UndoRedoEntity {
+    constructor(appObject) {
+        super(appObject, UndoRedoEntity_1.UndoRedoEntity.type);
+        this.submitAction = jest.fn();
+        this.doUndo = jest.fn();
+        this.doRedo = jest.fn();
+        this.clearStack = jest.fn();
+    }
+    get hasUndo() {
+        throw new Error("Method not implemented.");
+    }
+    get hasRedo() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MockUndoRedo = MockUndoRedo;

package/lib/Components/UndoRedo/PM/HasRedoPM.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 HasRedoPM extends AppObjectPM<boolean> {
+    static readonly type = "HasRedoPM";
+    static get: (appObjects: AppObjectRepo) => HasRedoPM | undefined;
+}
+export declare function makeHasRedoPM(appObject: AppObject): HasRedoPM;

package/lib/Components/UndoRedo/PM/HasRedoPM.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHasRedoPM = exports.HasRedoPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const UndoRedoEntity_1 = require("../Entities/UndoRedoEntity");
+class HasRedoPM extends AppObjectPM_1.AppObjectPM {
+}
+exports.HasRedoPM = HasRedoPM;
+HasRedoPM.type = "HasRedoPM";
+HasRedoPM.get = (appObjects) => AppObject_1.getSingletonComponent(HasRedoPM.type, appObjects);
+function makeHasRedoPM(appObject) {
+    return new HasRedoPMImp(appObject);
+}
+exports.makeHasRedoPM = makeHasRedoPM;
+class HasRedoPMImp extends HasRedoPM {
+    constructor(appObject) {
+        super(appObject, HasRedoPM.type);
+        this.dispose = () => {
+            var _a;
+            super.dispose();
+            (_a = this.undoRedoEntity) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEntityChange);
+        };
+        this.onEntityChange = () => {
+            if (!this.undoRedoEntity)
+                return;
+            this.doUpdateView(this.undoRedoEntity.hasRedo);
+        };
+        this.undoRedoEntity = appObject.getComponent(UndoRedoEntity_1.UndoRedoEntity.type);
+        if (this.undoRedoEntity) {
+            this.undoRedoEntity.addChangeObserver(this.onEntityChange);
+            this.onEntityChange();
+        }
+        else {
+            this.warn("HasRedoPM has been added to an app object that does not have UndoRedoEntity");
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

package/lib/Components/UndoRedo/PM/HasUndoPM.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 HasUndoPM extends AppObjectPM<boolean> {
+    static readonly type = "HasUndoPM";
+    static get: (appObjects: AppObjectRepo) => HasUndoPM | undefined;
+}
+export declare function makeHasUndoPM(appObject: AppObject): HasUndoPM;

package/lib/Components/UndoRedo/PM/HasUndoPM.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHasUndoPM = exports.HasUndoPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const UndoRedoEntity_1 = require("../Entities/UndoRedoEntity");
+class HasUndoPM extends AppObjectPM_1.AppObjectPM {
+}
+exports.HasUndoPM = HasUndoPM;
+HasUndoPM.type = "HasUndoPM";
+HasUndoPM.get = (appObjects) => AppObject_1.getSingletonComponent(HasUndoPM.type, appObjects);
+function makeHasUndoPM(appObject) {
+    return new HasUndoPMImp(appObject);
+}
+exports.makeHasUndoPM = makeHasUndoPM;
+class HasUndoPMImp extends HasUndoPM {
+    constructor(appObject) {
+        super(appObject, HasUndoPM.type);
+        this.dispose = () => {
+            var _a;
+            super.dispose();
+            (_a = this.undoRedoEntity) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEntityChange);
+        };
+        this.onEntityChange = () => {
+            if (!this.undoRedoEntity)
+                return;
+            this.doUpdateView(this.undoRedoEntity.hasUndo);
+        };
+        this.undoRedoEntity = appObject.getComponent(UndoRedoEntity_1.UndoRedoEntity.type);
+        if (this.undoRedoEntity) {
+            this.undoRedoEntity.addChangeObserver(this.onEntityChange);
+            this.onEntityChange();
+        }
+        else {
+            this.warn("HasUndoPM has been added to an app object that does not have UndoRedoEntity");
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./HasRedoPM";
+export * from "./HasUndoPM";

package/lib/Components/UndoRedo/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("./HasRedoPM"), exports);
+__exportStar(require("./HasUndoPM"), exports);

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

@@ -0,0 +1,3 @@
+export * from "./Entities";
+export * from "./PM";
+export * from "./Controllers";

package/lib/Components/UndoRedo/index.js

@@ -0,0 +1,15 @@
+"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("./PM"), exports);
+__exportStar(require("./Controllers"), exports);

package/lib/Components/XR/Entity/index.d.ts

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

package/lib/Components/XR/Entity/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("./XREntity"), exports);

package/lib/Components/XR/Mocks/MockRenderToXR.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { RenderToXR } from "../UC";
+export declare class MockRenderToXR extends RenderToXR {
+    startRenderingXR: jest.Mock<any, any>;
+    stopRenderingXR: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/XR/Mocks/MockRenderToXR.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockRenderToXR = void 0;
+const UC_1 = require("../UC");
+class MockRenderToXR extends UC_1.RenderToXR {
+    constructor(appObject) {
+        super(appObject, UC_1.RenderToXR.type);
+        this.startRenderingXR = jest.fn();
+        this.stopRenderingXR = jest.fn();
+    }
+}
+exports.MockRenderToXR = MockRenderToXR;