@vived/app 4.13.0 → 4.14.1

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScaleTransformSC = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const Stylus_1 = require("../../../Stylus");
+const UC_1 = require("../../UC");
+class ScaleTransformSC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, ScaleTransformSC.type);
+        this.doUpdate = false;
+        this.allow = (button) => {
+            if (button === 0)
+                return true;
+            return false;
+        };
+        this.onButtonDown = (button) => {
+            this.doUpdate = false;
+            if (!this.stylus || !this.uc)
+                return;
+            if (!this.allow(button))
+                return;
+            this.uc.initializeRay(this.stylus.pickRay);
+            this.doUpdate = true;
+        };
+        this.onButtonUp = () => {
+            if (!this.doUpdate)
+                return;
+            this.doUpdate = false;
+            if (!this.uc)
+                return;
+            this.uc.finish();
+        };
+        this.onStylusMove = () => {
+            if (!this.stylus || !this.uc)
+                return;
+            if (!this.doUpdate)
+                return;
+            this.uc.updateRay(this.stylus.pickRay);
+        };
+        this.stylus = Stylus_1.StylusEntity.get(this.appObjects);
+        if (!this.stylus) {
+            this.error("Unable to find StylusEntity");
+            return;
+        }
+        this.uc = appObject.getComponent(UC_1.ScaleTransformUC.type);
+        if (!this.uc) {
+            this.error("App Object that does not have a RayScaleTransformUC");
+            return;
+        }
+        this.stylus.registerController(this);
+    }
+}
+exports.ScaleTransformSC = ScaleTransformSC;
+ScaleTransformSC.type = "ScaleTransformSC";

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

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

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

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

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { TouchController, TouchInputEvent } from "../../../TouchController";
+import { ScaleTransformUC } from "../../UC";
+export declare class DragScaleTransformTC extends AppObjectController implements TouchController {
+    static readonly type = "DragScaleTransformTC";
+    private isScaling;
+    scaleUC?: ScaleTransformUC;
+    allow: (e: TouchInputEvent) => boolean;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragScaleTransformTC = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const TouchController_1 = require("../../../TouchController");
+const UC_1 = require("../../UC");
+class DragScaleTransformTC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, DragScaleTransformTC.type);
+        this.isScaling = false;
+        this.allow = (e) => {
+            if (e.touches.length !== 1) {
+                return false;
+            }
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            var _a;
+            this.isScaling = false;
+            if (e.touches.length !== 1) {
+                return;
+            }
+            if (!this.allow(e)) {
+                return;
+            }
+            const pixelPosition = e.touches[0].position;
+            (_a = this.scaleUC) === null || _a === void 0 ? void 0 : _a.initializePixel(pixelPosition);
+            this.isScaling = true;
+        };
+        this.onTouchMove = (e) => {
+            var _a;
+            if (!this.isScaling)
+                return;
+            if (e.touches.length !== 1)
+                return;
+            const pixelPosition = e.touches[0].position;
+            (_a = this.scaleUC) === null || _a === void 0 ? void 0 : _a.updatePixel(pixelPosition);
+        };
+        this.onTouchEnd = () => {
+            var _a;
+            this.isScaling = false;
+            (_a = this.scaleUC) === null || _a === void 0 ? void 0 : _a.finish();
+        };
+        const appObjects = appObject.appObjectRepo;
+        this.scaleUC = appObject.getComponent(UC_1.ScaleTransformUC.type);
+        if (!this.scaleUC) {
+            this.error("App Object that does not have ScaleTransformUC");
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find TouchInputEntity");
+        }
+    }
+}
+exports.DragScaleTransformTC = DragScaleTransformTC;
+DragScaleTransformTC.type = "DragScaleTransformTC";

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

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

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PanTransformTC = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const TouchController_1 = require("../../../TouchController");
+const UC_1 = require("../../UC");
+class PanTransformTC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, PanTransformTC.type);
+        this.isPanning = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            var _a, _b;
+            if (!this.allow(e)) {
+                this.isPanning = false;
+                (_a = this.panUC) === null || _a === void 0 ? void 0 : _a.cancelPan();
+                return;
+            }
+            (_b = this.panUC) === null || _b === void 0 ? void 0 : _b.initializePixel(e.touchCenter);
+            this.isPanning = true;
+        };
+        this.onTouchMove = (e) => {
+            var _a;
+            if (!this.isPanning)
+                return;
+            const pixelPosition = e.touches[0].position;
+            (_a = this.panUC) === null || _a === void 0 ? void 0 : _a.updatePixel(pixelPosition);
+        };
+        this.onTouchEnd = (e) => {
+            var _a;
+            this.isPanning = false;
+            (_a = this.panUC) === null || _a === void 0 ? void 0 : _a.finish();
+        };
+        const appObjects = appObject.appObjectRepo;
+        this.panUC = appObject.getComponent(UC_1.PanTransformUC.type);
+        if (!this.panUC) {
+            this.warn("Controller has been added to an App Object that does not have PanTransformUC. Add one first.");
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find TouchInputEntity");
+        }
+    }
+}
+exports.PanTransformTC = PanTransformTC;
+PanTransformTC.type = "PanTransformTC";

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

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { TouchController, TouchInputEvent } from "../../../TouchController";
+import { PinchTransformUC } from "../../UC";
+export declare class PinchTransformTC extends AppObjectController implements TouchController {
+    static readonly type = "PinchTransformTC";
+    private isPinching;
+    pinchUC?: PinchTransformUC;
+    allow: (e: TouchInputEvent) => boolean;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinchTransformTC = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const TouchController_1 = require("../../../TouchController");
+const UC_1 = require("../../UC");
+class PinchTransformTC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, PinchTransformTC.type);
+        this.isPinching = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            var _a;
+            this.isPinching = false;
+            if (e.touches.length !== 2) {
+                return;
+            }
+            if (!this.allow(e)) {
+                return;
+            }
+            (_a = this.pinchUC) === null || _a === void 0 ? void 0 : _a.initializePinch(e.touches[0].position, e.touches[1].position);
+            this.isPinching = true;
+        };
+        this.onTouchMove = (e) => {
+            var _a;
+            if (!this.isPinching)
+                return;
+            if (e.touches.length !== 2)
+                return;
+            (_a = this.pinchUC) === null || _a === void 0 ? void 0 : _a.doPinch(e.touches[0].position, e.touches[1].position);
+        };
+        this.onTouchEnd = () => {
+            var _a;
+            this.isPinching = false;
+            (_a = this.pinchUC) === null || _a === void 0 ? void 0 : _a.finishPinch();
+        };
+        const appObjects = appObject.appObjectRepo;
+        this.pinchUC = appObject.getComponent(UC_1.PinchTransformUC.type);
+        if (!this.pinchUC) {
+            this.error("App Object does not have PinchTransformUC");
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find TouchInputEntity");
+        }
+    }
+}
+exports.PinchTransformTC = PinchTransformTC;
+PinchTransformTC.type = "PinchTransformTC";

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

@@ -0,0 +1,3 @@
+export * from "./DragScaleTransformTC";
+export * from "./PanTransformTC";
+export * from "./PinchTransformTC";

package/lib/Components/Transform3D/Controllers/Touch/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("./DragScaleTransformTC"), exports);
+__exportStar(require("./PanTransformTC"), exports);
+__exportStar(require("./PinchTransformTC"), exports);

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

@@ -0,0 +1,3 @@
+export * from "./Mouse";
+export * from "./Stylus";
+export * from "./Touch";

package/lib/Components/Transform3D/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("./Mouse"), exports);
+__exportStar(require("./Stylus"), exports);
+__exportStar(require("./Touch"), exports);

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

@@ -0,0 +1,14 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { ParametricPlane } from "../../../ValueObjects";
+import { BumpTransformScaleAboutPixelPointUC } from "../UC";
+export declare class MockBumpTransformScaleAboutPixelPoint extends BumpTransformScaleAboutPixelPointUC {
+    enabled: boolean;
+    minScale?: number | undefined;
+    maxScale?: number | undefined;
+    pickPlane?: ParametricPlane | undefined;
+    sensitivity: number;
+    allow: jest.Mock<any, any>;
+    bump: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockBumpTransformScaleAboutPixelPoint = void 0;
+const UC_1 = require("../UC");
+class MockBumpTransformScaleAboutPixelPoint extends UC_1.BumpTransformScaleAboutPixelPointUC {
+    constructor(appObject) {
+        super(appObject, UC_1.BumpTransformScaleAboutPixelPointUC.type);
+        this.enabled = true;
+        this.sensitivity = 1;
+        this.allow = jest.fn();
+        this.bump = jest.fn();
+    }
+}
+exports.MockBumpTransformScaleAboutPixelPoint = MockBumpTransformScaleAboutPixelPoint;

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

@@ -0,0 +1,18 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { PanTransformUC } from "../UC";
+export declare class MockPanTransformUC extends PanTransformUC {
+    enabled: boolean;
+    minX?: number | undefined;
+    maxX?: number | undefined;
+    minY?: number | undefined;
+    maxY?: number | undefined;
+    dispatchStateChangeOnComplete: boolean;
+    updatePixel: jest.Mock<any, any>;
+    initializePixel: jest.Mock<any, any>;
+    finish: jest.Mock<any, any>;
+    cancelPan: jest.Mock<any, any>;
+    updateRay: jest.Mock<any, any>;
+    initializeRay: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockPanTransformUC = void 0;
+const UC_1 = require("../UC");
+class MockPanTransformUC extends UC_1.PanTransformUC {
+    constructor(appObject) {
+        super(appObject, UC_1.PanTransformUC.type);
+        this.enabled = true;
+        this.dispatchStateChangeOnComplete = false;
+        this.updatePixel = jest.fn();
+        this.initializePixel = jest.fn();
+        this.finish = jest.fn();
+        this.cancelPan = jest.fn();
+        this.updateRay = jest.fn();
+        this.initializeRay = jest.fn();
+    }
+}
+exports.MockPanTransformUC = MockPanTransformUC;

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

@@ -0,0 +1,15 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { ParametricPlane } from "../../../ValueObjects";
+import { PinchTransformUC } from "../UC";
+export declare class MockPinchTransformUC extends PinchTransformUC {
+    enabled: boolean;
+    sensitivity: number;
+    minScale?: number | undefined;
+    maxScale?: number | undefined;
+    pickPlane?: ParametricPlane | undefined;
+    doPinch: jest.Mock<any, any>;
+    initializePinch: jest.Mock<any, any>;
+    finishPinch: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockPinchTransformUC = void 0;
+const UC_1 = require("../UC");
+class MockPinchTransformUC extends UC_1.PinchTransformUC {
+    constructor(appObject) {
+        super(appObject, UC_1.PinchTransformUC.type);
+        this.enabled = true;
+        this.sensitivity = 0;
+        this.doPinch = jest.fn();
+        this.initializePinch = jest.fn();
+        this.finishPinch = jest.fn();
+    }
+}
+exports.MockPinchTransformUC = MockPinchTransformUC;

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

@@ -0,0 +1,19 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { ParametricPlane } from "../../../ValueObjects";
+import { RayPanScaleTransformUC } from "../UC";
+export declare class MockRayPanScaleTransformUC extends RayPanScaleTransformUC {
+    enabled: boolean;
+    sensitivity: number;
+    minScale?: number | undefined;
+    maxScale?: number | undefined;
+    minX?: number | undefined;
+    maxX?: number | undefined;
+    minY?: number | undefined;
+    maxY?: number | undefined;
+    pickPlane?: ParametricPlane | undefined;
+    update: jest.Mock<any, any>;
+    initialize: jest.Mock<any, any>;
+    finish: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockRayPanScaleTransformUC = void 0;
+const UC_1 = require("../UC");
+class MockRayPanScaleTransformUC extends UC_1.RayPanScaleTransformUC {
+    constructor(appObject) {
+        super(appObject, UC_1.RayPanScaleTransformUC.type);
+        this.enabled = true;
+        this.sensitivity = 1;
+        this.update = jest.fn();
+        this.initialize = jest.fn();
+        this.finish = jest.fn();
+    }
+}
+exports.MockRayPanScaleTransformUC = MockRayPanScaleTransformUC;

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

@@ -0,0 +1,18 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { ParametricPlane } from "../../../ValueObjects";
+import { ScaleTransformUC } from "../UC";
+export declare class MockRayScaleTransform extends ScaleTransformUC {
+    enabled: boolean;
+    pixelSensitivity: number;
+    raySensitivity: number;
+    minScale?: number | undefined;
+    maxScale?: number | undefined;
+    pickPlane?: ParametricPlane | undefined;
+    updateRay: jest.Mock<any, any>;
+    initializeRay: jest.Mock<any, any>;
+    finish: jest.Mock<any, any>;
+    initializePixel: jest.Mock<any, any>;
+    updatePixel: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockRayScaleTransform = void 0;
+const UC_1 = require("../UC");
+class MockRayScaleTransform extends UC_1.ScaleTransformUC {
+    constructor(appObject) {
+        super(appObject, UC_1.ScaleTransformUC.type);
+        this.enabled = true;
+        this.pixelSensitivity = 1;
+        this.raySensitivity = 1;
+        this.updateRay = jest.fn();
+        this.initializeRay = jest.fn();
+        this.finish = jest.fn();
+        this.initializePixel = jest.fn();
+        this.updatePixel = jest.fn();
+    }
+}
+exports.MockRayScaleTransform = MockRayScaleTransform;

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

@@ -0,0 +1,5 @@
+export * from "./MockBumpTransformScaleAboutPixelPoint";
+export * from "./MockPanTransformUC";
+export * from "./MockPinchTransformUC";
+export * from "./MockRayPanScaleTransformUC";
+export * from "./MockRayScaleTransform";

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

@@ -0,0 +1,17 @@
+"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("./MockBumpTransformScaleAboutPixelPoint"), exports);
+__exportStar(require("./MockPanTransformUC"), exports);
+__exportStar(require("./MockPinchTransformUC"), exports);
+__exportStar(require("./MockRayPanScaleTransformUC"), exports);
+__exportStar(require("./MockRayScaleTransform"), exports);

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

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { ParametricPlane, Vector2 } from "../../../ValueObjects";
+export declare abstract class BumpTransformScaleAboutPixelPointUC extends AppObjectUC {
+    static readonly type = "BumpTransformScaleAboutPixelPointUC";
+    abstract sensitivity: number;
+    abstract minScale?: number | undefined;
+    abstract maxScale?: number | undefined;
+    abstract pickPlane?: ParametricPlane;
+    abstract enabled: boolean;
+    abstract allow(): boolean;
+    abstract bump(direction: "IN" | "OUT", pixelPosition: Vector2): void;
+}
+export declare function makeBumpTransformScaleAboutPixelPointUC(appObject: AppObject): BumpTransformScaleAboutPixelPointUC;

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBumpTransformScaleAboutPixelPointUC = exports.BumpTransformScaleAboutPixelPointUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entities_1 = require("../Entities");
+class BumpTransformScaleAboutPixelPointUC extends AppObject_1.AppObjectUC {
+}
+exports.BumpTransformScaleAboutPixelPointUC = BumpTransformScaleAboutPixelPointUC;
+BumpTransformScaleAboutPixelPointUC.type = "BumpTransformScaleAboutPixelPointUC";
+function makeBumpTransformScaleAboutPixelPointUC(appObject) {
+    return new BumpTransformScaleAboutPixelPointUCImp(appObject);
+}
+exports.makeBumpTransformScaleAboutPixelPointUC = makeBumpTransformScaleAboutPixelPointUC;
+class BumpTransformScaleAboutPixelPointUCImp extends BumpTransformScaleAboutPixelPointUC {
+    constructor(appObject) {
+        super(appObject, BumpTransformScaleAboutPixelPointUC.type);
+        this.enabled = true;
+        this.sensitivity = 0.1;
+        this.allow = () => {
+            return true;
+        };
+        this.bump = (direction, pixelPosition) => {
+            var _a, _b, _c;
+            if (!this.enabled)
+                return;
+            if (!this.transform)
+                return;
+            if (!this.allow())
+                return;
+            let bumpDirection = -1;
+            if (direction === "IN") {
+                bumpDirection = 1;
+            }
+            const currentScale = this.transform.worldScale.x;
+            const scaleDelta = bumpDirection * this.sensitivity * currentScale;
+            let pickPoint = ValueObjects_1.Vector3.Zero();
+            if (this.pickPlane) {
+                const pickRay = Babylon_1.pixelToSceneRay(pixelPosition, this.appObjects);
+                pickPoint = (_a = this.pickPlane.intersectLine(pickRay)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            }
+            else {
+                pickPoint = (_c = (_b = Babylon_1.scenePixelPick(pixelPosition, this.appObjects)) === null || _b === void 0 ? void 0 : _b.worldPickPoint) !== null && _c !== void 0 ? _c : ValueObjects_1.Vector3.Zero();
+            }
+            this.bumpScaleAboutPoint(scaleDelta, pickPoint);
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.bumpScaleAboutPoint = (amount, worldPoint) => {
+            if (!this.transform)
+                return;
+            const localPickOffset = this.transform.worldPointToLocal(worldPoint);
+            const currentScale = this.transform.worldScale.x;
+            let newScale = currentScale + amount;
+            if (this.minScale !== undefined && newScale < this.minScale) {
+                newScale = this.minScale;
+            }
+            if (this.maxScale !== undefined && newScale > this.maxScale) {
+                newScale = this.maxScale;
+            }
+            this.transform.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
+            const worldPickOffset = this.transform.localPointToWorld(localPickOffset);
+            const bump = ValueObjects_1.Vector3.Subtract(worldPoint, worldPickOffset);
+            this.transform.worldPosition = ValueObjects_1.Vector3.Add(bump, this.transform.worldPosition);
+        };
+        this.transform = appObject.getComponent(Entities_1.Transform3D.type);
+        if (!this.transform) {
+            this.error("BumpSceneRootScaleAboutPixelPointImp UC has been added to an App Object that does not have a Transform");
+            return;
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { ParametricLine, Vector2 } from "../../../ValueObjects";
+export declare abstract class PanTransformUC extends AppObjectUC {
+    static readonly type = "PanTransformUC";
+    abstract minX?: number;
+    abstract maxX?: number;
+    abstract minY?: number;
+    abstract maxY?: number;
+    abstract dispatchStateChangeOnComplete: boolean;
+    abstract enabled: boolean;
+    abstract updatePixel: (pixel: Vector2) => void;
+    abstract initializePixel: (pixel: Vector2) => void;
+    abstract updateRay: (ray: ParametricLine) => void;
+    abstract initializeRay: (ray: ParametricLine) => void;
+    abstract finish: () => void;
+    abstract cancelPan: () => void;
+}
+export declare function makePanTransformUC(appObject: AppObject): PanTransformUC;