@shopware-ag/dive 1.2.0 → 1.3.1

package/src/toolbox/BaseTool.ts

@@ -1,18 +1,268 @@
+import { Intersection, Object3D, Raycaster, Vector2, Vector3 } from "three";
+import { PRODUCT_LAYER_MASK, UI_LAYER_MASK } from "../constant/VisibilityLayerMask";
+import DIVEScene from "../scene/Scene";
+import DIVEOrbitControls from "../controls/OrbitControls";
+import { DIVEDraggable, findDraggableInterface } from "../interface/Draggable";
+import { DIVEHoverable, findHoverableInterface } from "../interface/Hoverable";
+
+export type DraggableEvent = {
+    dragStart: Vector3;
+    dragCurrent: Vector3;
+    dragEnd: Vector3;
+    dragDelta: Vector3;
+}
+
 /* eslint-disable @typescript-eslint/no-unused-vars */
 export default abstract class DIVEBaseTool {
-    protected name: string;
+    readonly POINTER_DRAG_THRESHOLD: number = 0.001;
+
+    public name: string;
+
+    protected _canvas: HTMLElement;
+    protected _scene: DIVEScene;
+    protected _controller: DIVEOrbitControls;
+
+    // general pointer members
+    protected _pointer: Vector2;
+
+    protected get _pointerAnyDown(): boolean {
+        return this._pointerPrimaryDown
+            || this._pointerMiddleDown
+            || this._pointerSecondaryDown;
+    };
+    protected _pointerPrimaryDown: boolean;
+    protected _pointerMiddleDown: boolean;
+    protected _pointerSecondaryDown: boolean;
+    protected _lastPointerDown: Vector2;
+    protected _lastPointerUp: Vector2;
+
+    // raycast members
+    protected _raycaster: Raycaster;
+    protected _intersects: Intersection[];
 
-    protected constructor() {
+    // hovering members
+    protected _hovered: (Object3D & DIVEHoverable) | null;
+
+    // dragging members
+    protected _dragging: boolean;
+    protected _dragStart: Vector3;
+    protected _dragCurrent: Vector3;
+    protected _dragEnd: Vector3;
+    protected _dragDelta: Vector3;
+    protected _draggable: DIVEDraggable | null;
+    protected _dragRaycastOnObjects: Object3D[] | null;
+
+    protected constructor(scene: DIVEScene, controller: DIVEOrbitControls) {
         this.name = "BaseTool";
+
+        this._canvas = controller.domElement;
+        this._scene = scene;
+        this._controller = controller;
+
+        this._pointer = new Vector2();
+
+        this._pointerPrimaryDown = false;
+        this._pointerMiddleDown = false;
+        this._pointerSecondaryDown = false;
+
+        this._lastPointerDown = new Vector2();
+        this._lastPointerUp = new Vector2();
+
+        this._raycaster = new Raycaster();
+        this._raycaster.layers.mask = PRODUCT_LAYER_MASK | UI_LAYER_MASK;
+        this._intersects = [];
+
+        this._hovered = null;
+
+        this._dragging = false;
+        this._dragStart = new Vector3();
+        this._dragCurrent = new Vector3();
+        this._dragEnd = new Vector3();
+        this._dragDelta = new Vector3();
+        this._draggable = null;
+        this._dragRaycastOnObjects = null;
     }
 
     public Activate(): void { }
 
     public Deactivate(): void { }
 
-    public onPointerDown(e: PointerEvent): void { }
+    public onPointerDown(e: PointerEvent): void {
+        switch (e.button) {
+            case 0:
+                this._pointerPrimaryDown = true;
+                break;
+            case 1:
+                this._pointerMiddleDown = true;
+                break;
+            case 2:
+                this._pointerSecondaryDown = true;
+                break;
+        }
+
+        this._lastPointerDown.copy(this._pointer);
+
+        this._draggable = findDraggableInterface(this._intersects[0]?.object) || null;
+    }
+
+    public onDragStart(e: PointerEvent): void {
+        if (!this._draggable) return;
+
+        if (this._dragRaycastOnObjects !== null) {
+            this._intersects = this._raycaster.intersectObjects(this._dragRaycastOnObjects, true);
+        }
+
+        if (this._intersects.length === 0) return;
+
+        this._dragStart.copy(this._intersects[0].point.clone());
+        this._dragCurrent.copy(this._intersects[0].point.clone());
+        this._dragEnd.copy(this._dragStart.clone());
+        this._dragDelta.set(0, 0, 0);
+
+        if (this._draggable && this._draggable.onDragStart) {
+            this._draggable.onDragStart({
+                dragStart: this._dragStart,
+                dragCurrent: this._dragCurrent,
+                dragEnd: this._dragEnd,
+                dragDelta: this._dragDelta,
+            });
+
+            this._dragging = true;
+            this._controller.enabled = false;
+        }
+    }
+
+    public onPointerMove(e: PointerEvent): void {
+        // update pointer
+        this._pointer.x = (e.offsetX / this._canvas.clientWidth) * 2 - 1;
+        this._pointer.y = -(e.offsetY / this._canvas.clientHeight) * 2 + 1;
+
+        // set raycaster
+        this._raycaster.setFromCamera(this._pointer, this._controller.object);
 
-    public onPointerUp(e: PointerEvent): void { }
+        // refresh intersects
+        this._intersects = this.raycast(this._scene.children);
+
+        // handle hover
+        const hoverable = findHoverableInterface(this._intersects[0]?.object);
+        if (this._intersects[0] && hoverable) {
+            if (!this._hovered) {
+                if (hoverable.onPointerEnter) hoverable.onPointerEnter(this._intersects[0]);
+                this._hovered = hoverable;
+                return;
+            }
+
+            if (this._hovered.uuid !== hoverable.uuid) {
+                if (this._hovered.onPointerLeave) this._hovered.onPointerLeave();
+                if (hoverable.onPointerEnter) hoverable.onPointerEnter(this._intersects[0]);
+                this._hovered = hoverable;
+                return;
+            }
+
+            if (hoverable.onPointerOver) hoverable.onPointerOver(this._intersects[0]);
+            this._hovered = hoverable;
+
+        } else {
+            if (this._hovered) {
+                if (this._hovered.onPointerLeave) this._hovered.onPointerLeave();
+            }
+
+            this._hovered = null;
+        }
+
+        // handle drag
+        if (this._pointerAnyDown) {
+            if (!this._dragging) {
+                this.onDragStart(e);
+            }
+
+            this.onDrag(e);
+        }
+    }
+
+    public onDrag(e: PointerEvent): void {
+        if (this._dragRaycastOnObjects !== null) {
+            this._intersects = this._raycaster.intersectObjects(this._dragRaycastOnObjects, true);
+        }
+        const intersect = this._intersects[0];
+        if (!intersect) return;
+
+        this._dragCurrent.copy(intersect.point.clone());
+        this._dragEnd.copy(intersect.point.clone());
+        this._dragDelta.subVectors(this._dragCurrent.clone(), this._dragStart.clone());
+
+        if (this._draggable && this._draggable.onDrag) {
+            this._draggable.onDrag({
+                dragStart: this._dragStart,
+                dragCurrent: this._dragCurrent,
+                dragEnd: this._dragEnd,
+                dragDelta: this._dragDelta,
+            });
+        }
+    }
+
+    public onPointerUp(e: PointerEvent): void {
+        if (this.pointerWasDragged() || this._dragging) {
+            if (this._draggable) {
+                this.onDragEnd(e);
+            }
+        } else {
+            this.onClick(e);
+        }
+
+        switch (e.button) {
+            case 0:
+                this._pointerPrimaryDown = false;
+                break;
+            case 1:
+                this._pointerMiddleDown = false;
+                break;
+            case 2:
+                this._pointerSecondaryDown = false;
+                break;
+        }
+
+        this._lastPointerUp.copy(this._pointer);
+    }
+
+    public onClick(e: PointerEvent): void { }
+
+    public onDragEnd(e: PointerEvent): void {
+        const intersect = this._intersects[0];
+        if (intersect) {
+            this._dragEnd.copy(intersect.point.clone());
+            this._dragCurrent.copy(intersect.point.clone());
+            this._dragDelta.subVectors(this._dragCurrent.clone(), this._dragStart.clone());
+        }
+
+        if (this._draggable && this._draggable.onDragEnd) {
+            this._draggable.onDragEnd({
+                dragStart: this._dragStart,
+                dragCurrent: this._dragCurrent,
+                dragEnd: this._dragEnd,
+                dragDelta: this._dragDelta,
+            });
+        }
+
+        this._draggable = null;
+        this._dragging = false;
+
+        this._dragStart.set(0, 0, 0);
+        this._dragCurrent.set(0, 0, 0);
+        this._dragEnd.set(0, 0, 0);
+        this._dragDelta.set(0, 0, 0);
+
+        this._controller.enabled = true;
+    }
 
     public onWheel(e: WheelEvent): void { }
+
+    protected raycast(objects?: Object3D[]): Intersection[] {
+        if (objects !== undefined) return this._raycaster.intersectObjects(objects, true);
+        return this._raycaster.intersectObjects(this._scene.children, true);
+    }
+
+    private pointerWasDragged(): boolean {
+        return this._lastPointerDown.distanceTo(this._pointer) > this.POINTER_DRAG_THRESHOLD;
+    }
 }

package/src/toolbox/Toolbox.ts

@@ -21,11 +21,13 @@ export default class DIVEToolbox {
     constructor(scene: DIVEScene, controller: DIVEOrbitControls) {
         this.selectTool = new DIVESelectTool(scene, controller);
 
+        controller.domElement.addEventListener('pointermove', this.onPointerMove.bind(this));
         controller.domElement.addEventListener('pointerdown', this.onPointerDown.bind(this));
         controller.domElement.addEventListener('pointerup', this.onPointerUp.bind(this));
         controller.domElement.addEventListener('wheel', this.onWheel.bind(this));
 
         this.removeListenersCallback = () => {
+            controller.domElement.removeEventListener('pointermove', this.onPointerMove.bind(this));
             controller.domElement.removeEventListener('pointerdown', this.onPointerDown.bind(this));
             controller.domElement.removeEventListener('pointerup', this.onPointerUp.bind(this));
             controller.domElement.removeEventListener('wheel', this.onWheel.bind(this));
@@ -62,6 +64,10 @@ export default class DIVEToolbox {
         this.selectTool.SetGizmoMode(mode);
     }
 
+    public onPointerMove(e: PointerEvent): void {
+        this.activeTool.onPointerMove(e);
+    }
+
     public onPointerDown(e: PointerEvent): void {
         this.activeTool.onPointerDown(e);
     }

package/src/toolbox/__test__/BaseTool.test.ts

@@ -0,0 +1,389 @@
+
+import { type Object3D, type Vector3 } from 'three';
+import DIVEOrbitControls from '../../controls/OrbitControls';
+import DIVEScene from '../../scene/Scene';
+import DIVEBaseTool from '../BaseTool';
+import DIVEToolbox from '../Toolbox';
+import { type DIVEHoverable } from '../../interface/Hoverable';
+import { DIVEDraggable } from '../../interface/Draggable';
+
+/**
+ * @jest-environment jsdom
+ */
+
+
+const mock_Canvas = {
+    width: 0,
+    height: 0,
+    getContext: jest.fn(),
+    clientWidth: 1000,
+    clientHeight: 1000,
+    offsetLeft: 0,
+    offsetTop: 0,
+};
+
+const mockController = {
+    domElement: mock_Canvas,
+    object: {
+        isPerspectiveCamera: true,
+        type: 'cameraP'
+    }
+} as unknown as DIVEOrbitControls;
+
+const mockScene = {
+    children: [],
+} as unknown as DIVEScene;
+
+const abstractWrapper = class Wrapper extends DIVEBaseTool {
+    constructor(scene: DIVEScene, controller: DIVEOrbitControls) {
+        super(scene, controller);
+        this.name = "DIVEBaseTool";
+    }
+};
+
+describe('dive/toolbox/DIVEBaseTool', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should instantiate', () => {
+        const toolBox = new abstractWrapper(mockScene, mockController);
+        expect(toolBox).toBeDefined();
+    });
+
+    it('should raycast', () => {
+        const toolBox = new abstractWrapper(mockScene, mockController);
+        expect(() => toolBox['raycast']()).not.toThrow();
+        expect(() => toolBox['raycast']([])).not.toThrow();
+    });
+
+    it('should return correct pointerAnyDown', () => {
+        const toolBox = new abstractWrapper(mockScene, mockController);
+        expect(toolBox).toBeDefined();
+        expect(toolBox['_pointerAnyDown']).toBeDefined();
+        expect(toolBox['_pointerAnyDown']).toBe(false);
+
+        toolBox['_pointerPrimaryDown'] = true;
+        expect(toolBox['_pointerAnyDown']).toBe(true);
+    });
+
+    it('should execute onPointerDown correctly', () => {
+        const toolBox = new abstractWrapper(mockScene, mockController);
+        expect(() => toolBox.onPointerDown({ button: 0 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerDown({ button: 1 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerDown({ button: 2 } as PointerEvent)).not.toThrow();
+
+        toolBox['_intersects'] = [
+            {
+                distance: 1,
+                point: {
+                    clone() {
+                        return {
+                            x: 1,
+                            y: 1,
+                            z: 1
+                        } as unknown as Vector3;
+                    },
+                    x: 1,
+                    y: 1,
+                    z: 1
+                } as unknown as Vector3,
+                object: {
+                    uuid: 'uuid2',
+                    isHoverable: true,
+                    onPointerEnter() {
+                        return;
+                    },
+                } as unknown as Object3D & DIVEHoverable
+            }
+        ];
+
+        expect(() => toolBox.onPointerDown({ button: 0 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerDown({ button: 1 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerDown({ button: 2 } as PointerEvent)).not.toThrow();
+    });
+
+    it('should execute onPointerMove correctly', () => {
+        const toolBox = new abstractWrapper(mockScene, mockController);
+        jest.spyOn(toolBox['_raycaster'], 'setFromCamera').mockImplementation();
+
+        // test with no hit with hovered object before
+        jest.spyOn(toolBox['_raycaster'], 'intersectObjects').mockReturnValueOnce([]);
+
+        toolBox['_hovered'] = {
+            uuid: 'uuid',
+            onPointerLeave() {
+                return;
+            },
+        } as Object3D & DIVEHoverable;
+
+        expect(() => toolBox.onPointerMove({ button: 0, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 1, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 2, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+
+        // test with no hovered object
+        jest.spyOn(toolBox['_raycaster'], 'intersectObjects').mockReturnValueOnce(
+            [
+                {
+                    distance: 1,
+                    point: {
+                        x: 1,
+                        y: 1,
+                        z: 1
+                    } as unknown as Vector3,
+                    object: {
+                        uuid: 'uuid',
+                        isHoverable: true,
+                    } as Object3D & DIVEHoverable
+                }
+            ]
+        );
+
+        toolBox['_hovered'] = null;
+
+        expect(() => toolBox.onPointerMove({ button: 0, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 1, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 2, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+
+        // test with no hovered object with onPointerEnter
+        jest.spyOn(toolBox['_raycaster'], 'intersectObjects').mockReturnValueOnce(
+            [
+                {
+                    distance: 1,
+                    point: {
+                        x: 1,
+                        y: 1,
+                        z: 1
+                    } as unknown as Vector3,
+                    object: {
+                        uuid: 'uuid',
+                        isHoverable: true,
+                        onPointerEnter() {
+                            return;
+                        },
+                    } as unknown as Object3D & DIVEHoverable
+                }
+            ]
+        );
+
+        expect(() => toolBox.onPointerMove({ button: 0, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 1, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 2, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+
+        // test with same hovered object
+        jest.spyOn(toolBox['_raycaster'], 'intersectObjects').mockReturnValueOnce(
+            [
+                {
+                    distance: 1,
+                    point: {
+                        x: 1,
+                        y: 1,
+                        z: 1
+                    } as unknown as Vector3,
+                    object: {
+                        uuid: 'uuid',
+                        isHoverable: true,
+                        onPointerOver() {
+                            return;
+                        }
+                    } as unknown as Object3D & DIVEHoverable
+                }
+            ]
+        );
+
+        toolBox['_hovered'] = {
+            uuid: 'uuid',
+            onPointerLeave() {
+                return;
+            },
+        } as Object3D & DIVEHoverable;
+
+        expect(() => toolBox.onPointerMove({ button: 0, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 1, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 2, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+
+        // test with different hovered object
+        jest.spyOn(toolBox['_raycaster'], 'intersectObjects').mockReturnValueOnce(
+            [
+                {
+                    distance: 1,
+                    point: {
+                        x: 1,
+                        y: 1,
+                        z: 1
+                    } as unknown as Vector3,
+                    object: {
+                        uuid: 'uuid2',
+                        isHoverable: true,
+                        onPointerEnter() {
+                            return;
+                        },
+                    } as unknown as Object3D & DIVEHoverable
+                }
+            ]
+        );
+
+        toolBox['_hovered'] = {
+            uuid: 'uuid',
+            onPointerLeave() {
+                return;
+            },
+        } as Object3D & DIVEHoverable;
+
+        expect(() => toolBox.onPointerMove({ button: 0, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 1, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 2, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+
+        // test with pointer down
+        toolBox['_pointerPrimaryDown'] = true;
+        expect(() => toolBox.onPointerMove({ button: 0, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 1, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 2, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+
+        // test with pointer down while already dragging
+        toolBox['_pointerPrimaryDown'] = true;
+        toolBox['_dragging'] = true;
+        expect(() => toolBox.onPointerMove({ button: 0, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 1, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerMove({ button: 2, offsetX: 100, offsetY: 100 } as PointerEvent)).not.toThrow();
+    });
+
+    it('should execute onPointerUp correctly', () => {
+        const toolBox = new abstractWrapper(mockScene, mockController);
+        expect(() => toolBox.onPointerUp({ button: 0 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerUp({ button: 1 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerUp({ button: 2 } as PointerEvent)).not.toThrow();
+
+        toolBox['pointerWasDragged'] = () => { return true; };
+        toolBox['_dragging'] = true;
+        toolBox['_intersects'] = [
+            {
+                distance: 1,
+                point: {
+                    clone() {
+                        return {
+                            x: 1,
+                            y: 1,
+                            z: 1
+                        } as unknown as Vector3;
+                    },
+                    x: 1,
+                    y: 1,
+                    z: 1
+                } as unknown as Vector3,
+                object: {
+                    uuid: 'uuid2',
+                    isHoverable: true,
+                    onPointerEnter() {
+                        return;
+                    },
+                } as unknown as Object3D & DIVEHoverable
+            }
+        ];
+        toolBox['_draggable'] = {
+            onDragEnd() {
+                return;
+            },
+        } as unknown as Object3D & DIVEDraggable;
+        expect(() => toolBox.onPointerUp({ button: 0 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerUp({ button: 1 } as PointerEvent)).not.toThrow();
+        expect(() => toolBox.onPointerUp({ button: 2 } as PointerEvent)).not.toThrow();
+    });
+
+    it('should execute onDragStart correctly', () => {
+        const toolBox = new abstractWrapper(mockScene, mockController);
+        expect(() => toolBox.onDragStart({} as PointerEvent)).not.toThrow();
+
+        toolBox['_draggable'] = {
+            onDragStart() {
+                return;
+            },
+        } as unknown as Object3D & DIVEDraggable;
+        expect(() => toolBox.onDragStart({} as PointerEvent)).not.toThrow();
+
+        toolBox['_dragRaycastOnObjects'] = [];
+        expect(() => toolBox.onDragStart({} as PointerEvent)).not.toThrow();
+
+        jest.spyOn(toolBox['_raycaster'], 'intersectObjects').mockReturnValueOnce([]);
+        expect(() => toolBox.onDragStart({} as PointerEvent)).not.toThrow();
+
+        jest.spyOn(toolBox['_raycaster'], 'intersectObjects').mockReturnValueOnce([
+            {
+                distance: 1,
+                point: {
+                    clone() {
+                        return {
+                            x: 1,
+                            y: 1,
+                            z: 1
+                        } as unknown as Vector3;
+                    },
+                    x: 1,
+                    y: 1,
+                    z: 1
+                } as unknown as Vector3,
+                object: {
+                    uuid: 'uuid2',
+                    isHoverable: true,
+                    onPointerEnter() {
+                        return;
+                    },
+                } as unknown as Object3D & DIVEHoverable
+            }
+        ]);
+        expect(() => toolBox.onDragStart({} as PointerEvent)).not.toThrow();
+
+        toolBox['_draggable'] = {
+            onDragStart() {
+                return;
+            },
+        } as unknown as Object3D & DIVEDraggable;
+        expect(() => toolBox.onDragStart({} as PointerEvent)).not.toThrow();
+    });
+
+    it('should execute onDrag correctly', () => {
+        const toolBox = new abstractWrapper(mockScene, mockController);
+        expect(() => toolBox.onDrag({} as PointerEvent)).not.toThrow();
+
+        toolBox['_dragRaycastOnObjects'] = [];
+        expect(() => toolBox.onDrag({} as PointerEvent)).not.toThrow();
+
+        toolBox['_draggable'] = {
+            onDrag() {
+                return;
+            },
+        } as unknown as Object3D & DIVEDraggable;
+        jest.spyOn(toolBox['_raycaster'], 'intersectObjects').mockReturnValueOnce(
+            [
+                {
+                    distance: 1,
+                    point: {
+                        clone() {
+                            return {
+                                x: 1,
+                                y: 1,
+                                z: 1
+                            } as unknown as Vector3;
+                        },
+                        x: 1,
+                        y: 1,
+                        z: 1
+                    } as unknown as Vector3,
+                    object: {
+                        uuid: 'uuid2',
+                        isHoverable: true,
+                        onPointerEnter() {
+                            return;
+                        },
+                    } as unknown as Object3D & DIVEHoverable
+                }
+            ]
+        );
+        expect(() => toolBox.onDrag({} as PointerEvent)).not.toThrow();
+    });
+
+    it('should execute onDragEnd correctly', () => {
+        const toolBox = new abstractWrapper(mockScene, mockController);
+        expect(() => toolBox.onDragEnd({} as PointerEvent)).not.toThrow();
+    });
+});