@vived/app 4.29.0 → 4.30.0

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;

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

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

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

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

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

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

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

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

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

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

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

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