@vived/app 4.28.2 → 4.30.0

package/lib/Components/Stick/Controllers/DoubleClickToStickMC.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoubleClickToStickMC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const MouseInput_1 = require("../../MouseInput");
+const TryStickAppObjectUC_1 = require("../UCs/TryStickAppObjectUC");
+class DoubleClickToStickMC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        var _a;
+        super(appObject, DoubleClickToStickMC.type);
+        this.maxClickTimeMS = 300;
+        this.maxClickDistancePx = 5;
+        this.initialClickPos = ValueObjects_1.Vector2.Zero();
+        this.initialClickTime = 0;
+        this.clickCount = 0;
+        this.onClick = (e) => {
+            if (!this.tryStickSceneMesh) {
+                this.error("Missing Component");
+                return;
+            }
+            if (e.button !== 0) {
+                this.cancelDoubleClick();
+                return;
+            }
+            this.clickCount = 1 + this.clickCount;
+            if (this.clickCount === 1) {
+                this.initialClickPos = e.position;
+                this.initialClickTime = Date.now();
+            }
+            else if (this.clickCount === 2) {
+                const movement = ValueObjects_1.Vector2.Subtract(this.initialClickPos, e.position).magnitued;
+                const passedTime = Date.now() - this.initialClickTime;
+                if (passedTime <= this.maxClickTimeMS &&
+                    movement <= this.maxClickDistancePx) {
+                    this.tryStickSceneMesh(e.position);
+                }
+                this.cancelDoubleClick();
+            }
+        };
+        this.cancelDoubleClick = () => {
+            this.initialClickPos = ValueObjects_1.Vector2.Zero();
+            this.initialClickTime = 0;
+            this.clickCount = 0;
+        };
+        (_a = this.mouseInput) === null || _a === void 0 ? void 0 : _a.registerController(this);
+    }
+    get mouseInput() {
+        return this.getCachedSingleton(MouseInput_1.MouseInputEntity.type);
+    }
+    get tryStickSceneMesh() {
+        var _a;
+        return (_a = this.getCachedSingleton(TryStickAppObjectUC_1.TryStickAppObjectUC.type)) === null || _a === void 0 ? void 0 : _a.tryWithPixel;
+    }
+}
+exports.DoubleClickToStickMC = DoubleClickToStickMC;
+DoubleClickToStickMC.type = "DoubleClickToStickMC";

package/lib/Components/Stick/Controllers/DoubleTapToStickTC.d.ts

@@ -0,0 +1,15 @@
+import { AppObject, AppObjectController } from "../../../AppObject";
+import { TouchController, TouchInputEvent } from "../../TouchController";
+export declare class DoubleTapToStickTC extends AppObjectController implements TouchController {
+    static type: string;
+    readonly tapTimeMS = 300;
+    readonly maxTapDistancePx = 30;
+    private initialTouchPos;
+    private initialTouchTime;
+    private tapCount;
+    private get touchInput();
+    private get tryStickSceneMesh();
+    onTap: (e: TouchInputEvent) => void;
+    private cancelDoubleTap;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Stick/Controllers/DoubleTapToStickTC.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoubleTapToStickTC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const TouchController_1 = require("../../TouchController");
+const TryStickAppObjectUC_1 = require("../UCs/TryStickAppObjectUC");
+class DoubleTapToStickTC extends AppObject_1.AppObjectController {
+    constructor(appObject) {
+        var _a;
+        super(appObject, DoubleTapToStickTC.type);
+        this.tapTimeMS = 300;
+        this.maxTapDistancePx = 30;
+        this.initialTouchPos = ValueObjects_1.Vector2.Zero();
+        this.initialTouchTime = 0;
+        this.tapCount = 0;
+        this.onTap = (e) => {
+            if (!this.tryStickSceneMesh) {
+                this.error("Missing Component");
+                return;
+            }
+            this.tapCount = 1 + this.tapCount;
+            if (this.tapCount === 1) {
+                this.initialTouchPos = e.touchCenter;
+                this.initialTouchTime = Date.now();
+            }
+            else if (this.tapCount === 2) {
+                const movement = ValueObjects_1.Vector2.Subtract(this.initialTouchPos, e.touchCenter).magnitued;
+                const passedTime = Date.now() - this.initialTouchTime;
+                if (passedTime <= this.tapTimeMS && movement <= this.maxTapDistancePx) {
+                    this.tryStickSceneMesh(e.touchCenter);
+                }
+                this.cancelDoubleTap();
+            }
+        };
+        this.cancelDoubleTap = () => {
+            this.initialTouchPos = ValueObjects_1.Vector2.Zero();
+            this.initialTouchTime = 0;
+            this.tapCount = 0;
+        };
+        (_a = this.touchInput) === null || _a === void 0 ? void 0 : _a.registerController(this);
+    }
+    get touchInput() {
+        return this.getCachedSingleton(TouchController_1.TouchInputEntity.type);
+    }
+    get tryStickSceneMesh() {
+        var _a;
+        return (_a = this.getCachedSingleton(TryStickAppObjectUC_1.TryStickAppObjectUC.type)) === null || _a === void 0 ? void 0 : _a.tryWithPixel;
+    }
+}
+exports.DoubleTapToStickTC = DoubleTapToStickTC;
+DoubleTapToStickTC.type = "DoubleTapToStickTC";

package/lib/Components/Stick/Controllers/clickStick.d.ts

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

package/lib/Components/Stick/Controllers/clickStick.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clickStick = void 0;
+const StickUC_1 = require("../UCs/StickUC");
+function clickStick(id, appObjects) {
+    const uc = StickUC_1.StickUC.get(id, appObjects);
+    if (!uc) {
+        appObjects.submitError("clickStick", "Unable to find StickUC");
+        return;
+    }
+    uc.doStick();
+}
+exports.clickStick = clickStick;

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

@@ -0,0 +1,3 @@
+export * from "./DoubleClickToStickMC";
+export * from "./DoubleTapToStickTC";
+export * from "./clickStick";

package/lib/Components/Stick/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("./DoubleClickToStickMC"), exports);
+__exportStar(require("./DoubleTapToStickTC"), exports);
+__exportStar(require("./clickStick"), exports);

package/lib/Components/Stick/Entities/Stickable.d.ts

@@ -0,0 +1,22 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+import { EaseFn } from "../../../Types";
+import { Quaternion, Vector3 } from "../../../ValueObjects";
+export declare abstract class StickableEntity extends AppObjectEntity {
+    static readonly type = "StickableEntity";
+    abstract get canBeStuck(): boolean;
+    abstract get stickPosition(): Vector3;
+    abstract set stickPosition(val: Vector3);
+    abstract get stickRotation(): Quaternion;
+    abstract set stickRotation(val: Quaternion);
+    abstract get stickScale(): number;
+    abstract set stickScale(val: number);
+    abstract get showStickTarget(): boolean;
+    abstract set showStickTarget(showStickTarget: boolean);
+    abstract get highlightTarget(): boolean;
+    abstract set highlightTarget(highlightTarget: boolean);
+    abstract stickDurationMS: number;
+    abstract easeFn: EaseFn;
+    abstract doStick(onCompleteCallback?: () => void): void;
+    static get(id: string, appObjects: AppObjectRepo): StickableEntity | undefined;
+}
+export declare function makeStickableEntity(appObject: AppObject): StickableEntity;

package/lib/Components/Stick/Entities/Stickable.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStickableEntity = exports.StickableEntity = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+const Utilities_1 = require("../../../Utilities");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+class StickableEntity extends AppObject_1.AppObjectEntity {
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects
+            .get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(StickableEntity.type);
+    }
+}
+exports.StickableEntity = StickableEntity;
+StickableEntity.type = "StickableEntity";
+function makeStickableEntity(appObject) {
+    return new StickableEntityImp(appObject);
+}
+exports.makeStickableEntity = makeStickableEntity;
+class StickableEntityImp extends StickableEntity {
+    constructor(appObject) {
+        super(appObject, StickableEntity.type);
+        this.stickDurationMS = 500;
+        this.easeFn = Utilities_1.expoOut;
+        this.memoizedCanBeStuck = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.memoizedStickPosition = new Entities_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notifyOnChange);
+        this.memoizedStickRotation = new Entities_1.MemoizedQuaternion(ValueObjects_1.Quaternion.Identity(), this.notifyOnChange);
+        this.memoizedStickScale = new Entities_1.MemoizedNumber(1, this.notifyOnChange);
+        this.memoizedShowStickTarget = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.memoizedHighlightTarget = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.checkIfStickable = () => {
+            if (!ValueObjects_1.Vector3.Equal(this.transform.localPosition, this.memoizedStickPosition.val)) {
+                this.memoizedCanBeStuck.val = true;
+                return;
+            }
+            if (this.transform.localScale.x !== this.memoizedStickScale.val) {
+                this.memoizedCanBeStuck.val = true;
+                return;
+            }
+            if (!ValueObjects_1.Quaternion.Close(this.transform.localRotation, this.memoizedStickRotation.val)) {
+                this.memoizedCanBeStuck.val = true;
+                return;
+            }
+            this.memoizedCanBeStuck.val = false;
+        };
+        this.transform = Transform3D_1.Transform3D.addIfMissing(appObject);
+        this.transform.addChangeObserver(this.checkIfStickable);
+        this.checkIfStickable();
+    }
+    doStick(onCompleteCallback) {
+        if (!this.canBeStuck)
+            return;
+        const lerpData = {
+            durationMS: this.stickDurationMS,
+            ease: this.easeFn,
+            desiredPosition: this.stickPosition,
+            desiredRotation: this.stickRotation,
+            desiredScale: new ValueObjects_1.Vector3(this.stickScale, this.stickScale, this.stickScale),
+            onCompletedCallback: onCompleteCallback
+        };
+        this.transform.lerp(lerpData);
+    }
+    get canBeStuck() {
+        return this.memoizedCanBeStuck.val;
+    }
+    get stickPosition() {
+        return this.memoizedStickPosition.val;
+    }
+    set stickPosition(val) {
+        this.memoizedStickPosition.val = val;
+        this.checkIfStickable();
+    }
+    get stickRotation() {
+        return this.memoizedStickRotation.val;
+    }
+    set stickRotation(val) {
+        this.memoizedStickRotation.val = val;
+        this.checkIfStickable();
+    }
+    get stickScale() {
+        return this.memoizedStickScale.val;
+    }
+    set stickScale(val) {
+        this.memoizedStickScale.val = val;
+        this.checkIfStickable();
+    }
+    get showStickTarget() {
+        return this.memoizedShowStickTarget.val;
+    }
+    set showStickTarget(showStickTarget) {
+        this.memoizedShowStickTarget.val = showStickTarget;
+    }
+    get highlightTarget() {
+        return this.memoizedHighlightTarget.val;
+    }
+    set highlightTarget(highlightTarget) {
+        this.memoizedHighlightTarget.val = highlightTarget;
+    }
+}

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

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

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

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

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

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

package/lib/Components/Stick/Factories/setupStick.d.ts

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

package/lib/Components/Stick/Factories/setupStick.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupStick = void 0;
+const DoubleClickToStickMC_1 = require("../Controllers/DoubleClickToStickMC");
+const DoubleTapToStickTC_1 = require("../Controllers/DoubleTapToStickTC");
+const TryStickAppObjectUC_1 = require("../UCs/TryStickAppObjectUC");
+function setupStick(appObjects) {
+    const ao = appObjects.getOrCreate("Stick");
+    // UCs
+    TryStickAppObjectUC_1.makeTryStickAppObjectUC(ao);
+    // Controllers
+    new DoubleClickToStickMC_1.DoubleClickToStickMC(ao);
+    new DoubleTapToStickTC_1.DoubleTapToStickTC(ao);
+}
+exports.setupStick = setupStick;

package/lib/Components/Stick/Mocks/StickTargetPmMock.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { StickTargetPM } from "../PMs/StickTargetPM";
+export declare class StickTargetPmMock extends StickTargetPM {
+    vmsAreEqual: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Stick/Mocks/StickTargetPmMock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StickTargetPmMock = void 0;
+const StickTargetPM_1 = require("../PMs/StickTargetPM");
+class StickTargetPmMock extends StickTargetPM_1.StickTargetPM {
+    constructor(appObject) {
+        super(appObject, StickTargetPM_1.StickTargetPM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.StickTargetPmMock = StickTargetPmMock;

package/lib/Components/Stick/Mocks/StickUCMock.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { StickUC } from "../UCs/StickUC";
+export declare class StickUCMock extends StickUC {
+    doStick: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Stick/Mocks/StickUCMock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StickUCMock = void 0;
+const StickUC_1 = require("../UCs/StickUC");
+class StickUCMock extends StickUC_1.StickUC {
+    constructor(appObject) {
+        super(appObject, StickUC_1.StickUC.type);
+        this.doStick = jest.fn();
+    }
+}
+exports.StickUCMock = StickUCMock;

package/lib/Components/Stick/Mocks/TryStickAppObjectUCMock.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { TryStickAppObjectUC } from "../UCs/TryStickAppObjectUC";
+export declare class TryStickAppObjectUCMock extends TryStickAppObjectUC {
+    allow: jest.Mock<any, any>;
+    tryWithRay: jest.Mock<any, any>;
+    tryWithPixel: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeTryStickAppObjectUCMock(appObjects: AppObjectRepo): TryStickAppObjectUCMock;

package/lib/Components/Stick/Mocks/TryStickAppObjectUCMock.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTryStickAppObjectUCMock = exports.TryStickAppObjectUCMock = void 0;
+const TryStickAppObjectUC_1 = require("../UCs/TryStickAppObjectUC");
+class TryStickAppObjectUCMock extends TryStickAppObjectUC_1.TryStickAppObjectUC {
+    constructor(appObject) {
+        super(appObject, TryStickAppObjectUC_1.TryStickAppObjectUC.type);
+        this.allow = jest.fn();
+        this.tryWithRay = jest.fn();
+        this.tryWithPixel = jest.fn();
+    }
+}
+exports.TryStickAppObjectUCMock = TryStickAppObjectUCMock;
+function makeTryStickAppObjectUCMock(appObjects) {
+    return new TryStickAppObjectUCMock(appObjects.getOrCreate("TryStickAppObjectUCMock"));
+}
+exports.makeTryStickAppObjectUCMock = makeTryStickAppObjectUCMock;

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

@@ -0,0 +1,3 @@
+export * from "./";
+export * from "./StickUCMock";
+export * from "./TryStickAppObjectUCMock";

package/lib/Components/Stick/Mocks/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("./"), exports);
+__exportStar(require("./StickUCMock"), exports);
+__exportStar(require("./TryStickAppObjectUCMock"), exports);

package/lib/Components/Stick/PMs/StickTargetPM.d.ts

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface StickTargetVM {
+    showStickTarget: boolean;
+    highlightTarget: boolean;
+}
+export declare abstract class StickTargetPM extends AppObjectPM<StickTargetVM> {
+    static readonly type = "StickTargetPM";
+    static get(id: string, appObjects: AppObjectRepo): StickTargetPM | undefined;
+}
+export declare function makeStickTargetPM(appObject: AppObject): StickTargetPM;
+export declare const defaultStickTargetVM: StickTargetVM;

package/lib/Components/Stick/PMs/StickTargetPM.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultStickTargetVM = exports.makeStickTargetPM = exports.StickTargetPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Stickable_1 = require("../Entities/Stickable");
+class StickTargetPM extends AppObject_1.AppObjectPM {
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects.get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(StickTargetPM.type);
+    }
+}
+exports.StickTargetPM = StickTargetPM;
+StickTargetPM.type = "StickTargetPM";
+function makeStickTargetPM(appObject) {
+    return new StickTargetPMImp(appObject);
+}
+exports.makeStickTargetPM = makeStickTargetPM;
+class StickTargetPMImp extends StickTargetPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, StickTargetPM.type);
+        this.onEntityChange = () => {
+            if (!this.entity)
+                return;
+            const showStickTarget = this.entity.showStickTarget;
+            const highlightTarget = this.entity.highlightTarget;
+            const vm = {
+                showStickTarget,
+                highlightTarget,
+            };
+            this.doUpdateView(vm);
+        };
+        (_a = this.entity) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+    }
+    get entity() {
+        return this.getCachedLocalComponent(Stickable_1.StickableEntity.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.highlightTarget !== b.highlightTarget)
+            return false;
+        if (a.showStickTarget !== b.showStickTarget)
+            return false;
+        return true;
+    }
+}
+exports.defaultStickTargetVM = {
+    showStickTarget: false,
+    highlightTarget: false,
+};

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

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

package/lib/Components/Stick/PMs/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("./StickTargetPM"), exports);

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

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