@shopware-ag/dive 1.15.3 → 1.15.4

package/src/toolbox/select/SelectTool.ts

@@ -1,9 +1,10 @@
 import { type Object3D } from "three";
 import { DIVEScene } from "../../scene/Scene.ts";
 import DIVETransformTool from "../transform/TransformTool.ts";
+import { findInterface } from "../../helper/findInterface/findInterface.ts";
 import type DIVEOrbitControls from "../../controls/OrbitControls.ts";
-import { type DIVESelectable, findSelectableInterface } from "../../interface/Selectable.ts";
-import { type DIVEMoveable } from "../../interface/Moveable.ts";
+import { type DIVESelectable } from "../../interface/Selectable.ts";
+import { type DIVEMovable } from "../../interface/Movable.ts";
 import { type DIVEBaseTool } from "../BaseTool.ts";
 
 export const isSelectTool = (tool: DIVEBaseTool): tool is DIVESelectTool => {
@@ -17,7 +18,7 @@ export interface DIVEObjectEventMap {
 /**
  * A Tool to select and move objects in the scene.
  *
- * Objects have to implement the DIVESelectable interface to be selectable and DIVEMoveable to be moveable.
+ * Objects have to implement the DIVESelectable interface to be selectable and DIVEMovable to be movable.
  *
  * @module
  */
@@ -46,8 +47,8 @@ export class DIVESelectTool extends DIVETransformTool {
     }
 
     public AttachGizmo(selectable: DIVESelectable): void {
-        if ('isMoveable' in selectable) {
-            const movable = selectable as (Object3D & DIVESelectable & DIVEMoveable);
+        if ('isMovable' in selectable) {
+            const movable = selectable as (Object3D & DIVESelectable & DIVEMovable);
             this._gizmo.attach(movable);
             this.SetGizmoVisibility(movable.visible);
         }
@@ -61,7 +62,7 @@ export class DIVESelectTool extends DIVETransformTool {
         super.onClick(e);
 
         const first = this._raycaster.intersectObjects(this._scene.Root.children, true).filter((intersect) => intersect.object.visible)[0];
-        const selectable = findSelectableInterface(first?.object);
+        const selectable = findInterface<DIVESelectable>(first?.object, 'isSelectable');
 
         // if nothing is hit
         if (!first || !selectable) {

package/src/toolbox/select/__test__/SelectTool.test.ts

@@ -234,7 +234,7 @@ describe('dive/toolbox/select/DIVESelectTool', () => {
         mock_intersectObjects.mockReturnValueOnce([{
             object: {
                 isSelectable: true,
-                isMoveable: true,
+                isMovable: true,
                 onSelect: mock_onSelect,
                 parent: {
                     name: 'this is the test scene root!!!',
@@ -250,7 +250,7 @@ describe('dive/toolbox/select/DIVESelectTool', () => {
         const selectTool = new DIVESelectTool(mockScene, mockController);
         const mock_onSelect = jest.fn();
         expect(() => selectTool.Select({ isSelectable: true })).not.toThrow();
-        expect(() => selectTool.Select({ isMoveable: true, onSelect: mock_onSelect } as unknown as DIVESelectable)).not.toThrow();
+        expect(() => selectTool.Select({ isMovable: true, onSelect: mock_onSelect } as unknown as DIVESelectable)).not.toThrow();
         expect(mock_onSelect).toHaveBeenCalledTimes(1);
     });
 
@@ -258,7 +258,7 @@ describe('dive/toolbox/select/DIVESelectTool', () => {
         const selectTool = new DIVESelectTool(mockScene, mockController);
         const mock_onDeselect = jest.fn();
         expect(() => selectTool.Deselect({ isSelectable: true })).not.toThrow();
-        expect(() => selectTool.Deselect({ isMoveable: true, onDeselect: mock_onDeselect } as unknown as DIVESelectable)).not.toThrow();
+        expect(() => selectTool.Deselect({ isMovable: true, onDeselect: mock_onDeselect } as unknown as DIVESelectable)).not.toThrow();
         expect(mock_onDeselect).toHaveBeenCalledTimes(1);
     });
 

package/src/toolbox/transform/TransformTool.ts

@@ -2,7 +2,8 @@ import { DIVEBaseTool } from "../BaseTool.ts";
 import { DIVEScene } from "../../scene/Scene.ts";
 import DIVEOrbitControls from "../../controls/OrbitControls.ts";
 import { TransformControls } from "three/examples/jsm/Addons";
-import { type DIVEMoveable } from "../../interface/Moveable.ts";
+import { type DIVEMovable } from "../../interface/Movable.ts";
+import { implementsInterface } from "../../helper/isInterface/implementsInterface.ts";
 
 export const isTransformTool = (tool: DIVEBaseTool): tool is DIVETransformTool => {
     return (tool as DIVETransformTool).isTransformTool !== undefined;
@@ -15,7 +16,7 @@ export interface DIVEObjectEventMap {
 /**
  * A Tool to select and move objects in the scene.
  *
- * Objects have to implement the DIVESelectable interface to be selectable and DIVEMoveable to be moveable.
+ * Objects have to implement the DIVESelectable interface to be selectable and DIVEMovable to be movable.
  *
  * @module
  */
@@ -32,19 +33,29 @@ export default class DIVETransformTool extends DIVEBaseTool {
         this._gizmo = new TransformControls(this._controller.object, this._controller.domElement);
         this._gizmo.mode = 'translate';
 
+        // happens when pointerDown event is called on gizmo
         this._gizmo.addEventListener('mouseDown', () => {
             controller.enabled = false;
+
+            if (!implementsInterface<DIVEMovable>(this._gizmo.object, 'isMovable')) return;
+            if (!this._gizmo.object.onMoveStart) return;
+            this._gizmo.object.onMoveStart();
+        });
+
+        // happens when pointerMove event is called on gizmo
+        this._gizmo.addEventListener('objectChange', () => {
+            if (!implementsInterface<DIVEMovable>(this._gizmo.object, 'isMovable')) return;
+            if (!this._gizmo.object.onMove) return;
+            this._gizmo.object.onMove();
         });
 
+        // happens when pointerUp event is called on gizmo
         this._gizmo.addEventListener('mouseUp', () => {
             controller.enabled = true;
-        });
 
-        this._gizmo.addEventListener('objectChange', () => {
-            if (!this._gizmo.object) return;
-            if (!('isMoveable' in this._gizmo.object)) return;
-            if (!('onMove' in this._gizmo.object)) return;
-            (this._gizmo.object as DIVEMoveable).onMove!();
+            if (!implementsInterface<DIVEMovable>(this._gizmo.object, 'isMovable')) return;
+            if (!this._gizmo.object.onMoveEnd) return;
+            this._gizmo.object.onMoveEnd();
         });
 
         scene.add(this._gizmo);

package/src/toolbox/transform/__test__/TransformTool.test.ts

@@ -108,12 +108,14 @@ jest.mock('three/examples/jsm/Addons.js', () => {
                 this.object = {};
                 callback({ value: false });
                 this.object = {
-                    isMoveable: true
+                    isMovable: true
                 };
                 callback({ value: false });
                 this.object = {
-                    isMoveable: true,
+                    isMovable: true,
                     onMove: jest.fn(),
+                    onMoveStart: jest.fn(),
+                    onMoveEnd: jest.fn(),
                 };
                 callback({ value: false });
             },

package/src/interface/Moveable.ts

@@ -1,11 +0,0 @@
-
-/**
- * Interface for objects that can be moved in the scene.
- *
- * @module
- */
-
-export interface DIVEMoveable {
-    isMoveable: true;
-    onMove?: () => void;
-}

package/src/interface/__test__/Interfaces.test.ts

@@ -1,87 +0,0 @@
-import { type Object3D } from 'three';
-import * as Moveable_DEF from '../Moveable';
-import * as Rotatable_DEF from '../Rotatable';
-import * as Scalable_DEF from '../Scalable';
-import * as Selectable_DEF from '../Selectable';
-import * as Draggable_DEF from '../Draggable';
-import * as Hoverable_DEF from '../Hoverable';
-
-describe('interfaces', () => {
-    it('should be defined', () => {
-        expect(Moveable_DEF).toBeDefined();
-        expect(Rotatable_DEF).toBeDefined();
-        expect(Scalable_DEF).toBeDefined();
-        expect(Selectable_DEF).toBeDefined();
-        expect(Draggable_DEF).toBeDefined();
-        expect(Hoverable_DEF).toBeDefined();
-    });
-
-    it('should identify Selectable', () => {
-        const Selectable = { isSelectable: true };
-        expect(Selectable_DEF.isSelectable(Selectable as unknown as Object3D)).toBe(true);
-    });
-
-    it('should find Selectable', () => {
-        let Selectable = {
-            isSelectable: true,
-        } as unknown as Object3D & Selectable_DEF.DIVESelectable;
-        expect(Selectable_DEF.findSelectableInterface(Selectable as unknown as Object3D)).toBe(Selectable);
-
-        let parent = {
-            isSelectable: true,
-        }
-        Selectable = {
-            parent: parent,
-        } as unknown as Object3D & Selectable_DEF.DIVESelectable;
-        expect(Selectable_DEF.findSelectableInterface(Selectable as unknown as Object3D)).toBe(parent);
-
-        Selectable = { isSelectable: true, parent: null } as unknown as Object3D & Selectable_DEF.DIVESelectable;
-        expect(Selectable_DEF.findSelectableInterface(Selectable as unknown as Object3D)).toBe(undefined);
-    });
-
-    it('should identify Draggable', () => {
-        const Draggable = { isDraggable: true };
-        expect(Draggable_DEF.isDraggable(Draggable as unknown as Object3D)).toBe(true);
-    });
-
-    it('should find Draggable', () => {
-        let Draggable = {
-            isDraggable: true,
-        } as unknown as Object3D & Draggable_DEF.DIVEDraggable;
-        expect(Draggable_DEF.findDraggableInterface(Draggable as unknown as Object3D)).toBe(Draggable);
-
-        let parent = {
-            isDraggable: true,
-        }
-        Draggable = {
-            parent: parent,
-        } as unknown as Object3D & Draggable_DEF.DIVEDraggable;
-        expect(Draggable_DEF.findDraggableInterface(Draggable as unknown as Object3D)).toBe(parent);
-
-        Draggable = { isDraggable: true, parent: null } as unknown as Object3D & Draggable_DEF.DIVEDraggable;
-        expect(Draggable_DEF.findDraggableInterface(Draggable as unknown as Object3D)).toBe(undefined);
-    });
-
-    it('should identify Hoverable', () => {
-        const Hoverable = { isHoverable: true };
-        expect(Hoverable_DEF.isHoverable(Hoverable as unknown as Object3D)).toBe(true);
-    });
-
-    it('should find Hoverable', () => {
-        let Hoverable = {
-            isHoverable: true,
-        } as unknown as Object3D & Hoverable_DEF.DIVEHoverable;
-        expect(Hoverable_DEF.findHoverableInterface(Hoverable as unknown as Object3D)).toBe(Hoverable);
-
-        let parent = {
-            isHoverable: true,
-        }
-        Hoverable = {
-            parent: parent,
-        } as unknown as Object3D & Hoverable_DEF.DIVEHoverable;
-        expect(Hoverable_DEF.findHoverableInterface(Hoverable as unknown as Object3D)).toBe(parent);
-
-        Hoverable = { isHoverable: true, parent: null } as unknown as Object3D & Hoverable_DEF.DIVEHoverable;
-        expect(Hoverable_DEF.findHoverableInterface(Hoverable as unknown as Object3D)).toBe(undefined);
-    });
-});