@shopware-ag/dive 1.16.8 → 1.16.9

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@shopware-ag/dive",
-    "version": "1.16.8",
+    "version": "1.16.9",
     "description": "Shopware Spatial Framework",
     "type": "module",
     "main": "./build/dive.cjs",

package/src/group/Group.ts

@@ -1,4 +1,10 @@
-import { BufferGeometry, Line, LineDashedMaterial, Vector3 } from 'three';
+import {
+    BufferGeometry,
+    Line,
+    LineDashedMaterial,
+    Vector3,
+    Vector3Like,
+} from 'three';
 import { DIVENode } from '../node/Node';
 import { type Object3D } from 'three';
 import { type DIVESceneObject } from '../types';
@@ -20,6 +26,15 @@ export class DIVEGroup extends DIVENode {
         this._lines = [];
     }
 
+    public SetPosition(position: Vector3Like): void {
+        super.SetPosition(position);
+        this._members.forEach((member) => {
+            if ('isDIVENode' in member) {
+                (member as DIVENode).onMove();
+            }
+        });
+    }
+
     public SetLinesVisibility(visible: boolean, object?: Object3D): void {
         if (!object) {
             this._lines.forEach((line) => {

package/src/group/__test__/Group.test.ts

@@ -1,4 +1,6 @@
+import { type Vector3Like } from 'three';
 import { DIVECommunication } from '../../com/Communication';
+import { type DIVENode } from '../../node/Node';
 import { DIVEGroup } from '../Group';
 
 jest.mock('../../com/Communication.ts', () => {
@@ -107,4 +109,99 @@ describe('dive/group/DIVEGroup', () => {
         jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
         expect(() => group.onMove()).not.toThrow();
     });
+
+    it('should call onMove on members with isDIVENode', () => {
+        // Create mock members
+        const diveNode1: DIVENode = {
+            isDIVENode: true,
+            onMove: jest.fn(),
+        } as unknown as DIVENode;
+
+        const diveNode2: DIVENode = {
+            isDIVENode: true,
+            onMove: jest.fn(),
+        } as unknown as DIVENode;
+
+        const member1: DIVENode = {
+            // Define other properties/methods if necessary
+        } as unknown as DIVENode;
+
+        const member2: DIVENode = {
+            // Define other properties/methods if necessary
+        } as unknown as DIVENode;
+
+        // Assign the _members array (assuming it's protected or public for testing)
+        // If _members is private, you might need to use a different approach or modify the class for testability
+        (group as any)._members = [
+            diveNode1,
+            member1,
+            diveNode2,
+            member2,
+        ];
+
+        const position: Vector3Like = { x: 4, y: 5, z: 6 };
+        group.SetPosition(position);
+
+        // Check that onMove was called on diveNode1 and diveNode2
+        expect(diveNode1.onMove).toHaveBeenCalled();
+        expect(diveNode2.onMove).toHaveBeenCalled();
+
+        // Ensure onMove was not called on other members
+        // Since member1 and member2 don't have onMove, there's nothing to assert here
+        // If members have onMove, you should mock and verify they are not called
+    });
+
+    it('should not call onMove on members without isDIVENode', () => {
+        // Create mock members without isDIVENode
+        const member1: DIVENode = {
+            // Define other properties/methods if necessary
+        } as unknown as DIVENode;
+
+        const member2: DIVENode = {
+            // Define other properties/methods if necessary
+        } as unknown as DIVENode;
+
+        // Assign the _members array
+        (group as any)._members = [
+            member1,
+            member2,
+        ];
+
+        const position: Vector3Like = { x: 7, y: 8, z: 9 };
+        group.SetPosition(position);
+
+        // Since members do not have onMove, there's nothing to assert
+        // If members have onMove as optional, you can spy on them to ensure they're not called
+    });
+
+    it('should handle an empty _members array without errors', () => {
+        // Assign an empty _members array
+        (group as any)._members = [];
+
+        const position: Vector3Like = { x: 10, y: 11, z: 12 };
+        expect(() => group.SetPosition(position)).not.toThrow();
+    });
+
+    it('should handle _members with mixed types correctly', () => {
+        // Create mixed members
+        const diveNode: DIVENode = {
+            isDIVENode: true,
+            onMove: jest.fn(),
+        } as unknown as DIVENode;
+
+        const member: DIVENode = {
+            // Define other properties/methods if necessary
+        } as unknown as DIVENode;
+
+        (group as any)._members = [
+            diveNode,
+            member,
+        ];
+
+        const position: Vector3Like = { x: 13, y: 14, z: 15 };
+        group.SetPosition(position);
+
+        // Ensure onMove is called only on diveNode
+        expect(diveNode.onMove).toHaveBeenCalled();
+    });
 });

package/src/math/degToRad/__test__/degToRad.test.ts

@@ -0,0 +1,179 @@
+import degToRad from '../degToRad';
+import { MathUtils } from 'three';
+
+// Mock the 'three' module, specifically MathUtils.degToRad
+jest.mock('three', () => ({
+    MathUtils: {
+        degToRad: jest.fn(),
+    },
+}));
+
+// Type assertion for the mocked MathUtils.degToRad
+const mockedDegToRad = MathUtils.degToRad as jest.Mock;
+
+/**
+ * Test Suite for degToRad Function
+ */
+describe('degToRad', () => {
+    beforeEach(() => {
+        // Clear all previous mock calls and implementations before each test
+        mockedDegToRad.mockClear();
+    });
+
+    it('should convert 0 degrees to 0 radians', () => {
+        // Arrange
+        mockedDegToRad.mockReturnValue(0);
+
+        // Act
+        const result = degToRad(0);
+
+        // Assert
+        expect(MathUtils.degToRad).toHaveBeenCalledWith(0);
+        expect(result).toBe(0);
+    });
+
+    it('should convert 180 degrees to π radians', () => {
+        // Arrange
+        const degrees = 180;
+        const radians = Math.PI;
+        mockedDegToRad.mockReturnValue(radians);
+
+        // Act
+        const result = degToRad(degrees);
+
+        // Assert
+        expect(MathUtils.degToRad).toHaveBeenCalledWith(degrees);
+        expect(result).toBe(radians);
+    });
+
+    it('should convert 360 degrees to 2π radians', () => {
+        // Arrange
+        const degrees = 360;
+        const radians = 2 * Math.PI;
+        mockedDegToRad.mockReturnValue(radians);
+
+        // Act
+        const result = degToRad(degrees);
+
+        // Assert
+        expect(MathUtils.degToRad).toHaveBeenCalledWith(degrees);
+        expect(result).toBe(radians);
+    });
+
+    it('should convert 90 degrees to π/2 radians', () => {
+        // Arrange
+        const degrees = 90;
+        const radians = Math.PI / 2;
+        mockedDegToRad.mockReturnValue(radians);
+
+        // Act
+        const result = degToRad(degrees);
+
+        // Assert
+        expect(MathUtils.degToRad).toHaveBeenCalledWith(degrees);
+        expect(result).toBe(radians);
+    });
+
+    it('should convert 45 degrees to π/4 radians', () => {
+        // Arrange
+        const degrees = 45;
+        const radians = Math.PI / 4;
+        mockedDegToRad.mockReturnValue(radians);
+
+        // Act
+        const result = degToRad(degrees);
+
+        // Assert
+        expect(MathUtils.degToRad).toHaveBeenCalledWith(degrees);
+        expect(result).toBe(radians);
+    });
+
+    it('should handle multiple calls with different degrees', () => {
+        // Arrange
+        const degrees1 = 30;
+        const radians1 = Math.PI / 6;
+        const degrees2 = 60;
+        const radians2 = Math.PI / 3;
+        const degrees3 = 120;
+        const radians3 = (2 * Math.PI) / 3;
+
+        mockedDegToRad
+            .mockReturnValueOnce(radians1)
+            .mockReturnValueOnce(radians2)
+            .mockReturnValueOnce(radians3);
+
+        // Act
+        const result1 = degToRad(degrees1);
+        const result2 = degToRad(degrees2);
+        const result3 = degToRad(degrees3);
+
+        // Assert
+        expect(MathUtils.degToRad).toHaveBeenNthCalledWith(1, degrees1);
+        expect(MathUtils.degToRad).toHaveBeenNthCalledWith(2, degrees2);
+        expect(MathUtils.degToRad).toHaveBeenNthCalledWith(3, degrees3);
+
+        expect(result1).toBe(radians1);
+        expect(result2).toBe(radians2);
+        expect(result3).toBe(radians3);
+    });
+
+    it('should handle edge case of degrees just below 360', () => {
+        // Arrange
+        const degrees = 359.999;
+        const radians = MathUtils.degToRad(degrees);
+        mockedDegToRad.mockReturnValue(radians);
+
+        // Act
+        const result = degToRad(degrees);
+
+        // Assert
+        expect(MathUtils.degToRad).toHaveBeenCalledWith(degrees);
+        expect(result).toBe(radians);
+    });
+
+    it('should not allow negative degrees', () => {
+        // Arrange
+        const degrees = -45;
+        const radians = MathUtils.degToRad(degrees);
+        mockedDegToRad.mockReturnValue(radians);
+
+        // Act
+        const result = degToRad(degrees);
+
+        // Assert
+        expect(MathUtils.degToRad).toHaveBeenCalledWith(degrees);
+        expect(result).toBe(radians);
+        // Depending on implementation, you might want to expect an error
+        // or handle negative degrees differently. Adjust assertions accordingly.
+    });
+
+    it('should handle undefined degrees gracefully', () => {
+        // Arrange
+        const degrees = undefined;
+        // Since the function expects a number, this might throw an error or pass undefined
+        mockedDegToRad.mockReturnValue(NaN);
+
+        // Act
+        // @ts-ignore: Testing undefined input
+        const result = degToRad(degrees);
+
+        // Assert
+        expect(MathUtils.degToRad).toHaveBeenCalledWith(degrees);
+        expect(result).toBe(NaN);
+    });
+
+    it('should handle null degrees gracefully', () => {
+        // Arrange
+        const degrees = null;
+        // Depending on implementation, this might throw an error or pass null
+        mockedDegToRad.mockReturnValue(NaN);
+
+        // Act
+        // @ts-ignore: Testing null input
+        const result = degToRad(degrees);
+
+        // Assert
+        expect(MathUtils.degToRad).toHaveBeenCalledWith(degrees);
+        expect(result).toBe(NaN);
+    });
+});

package/src/math/degToRad/degToRad.ts

@@ -0,0 +1,5 @@
+import { MathUtils } from 'three';
+
+export default function degToRad(degrees: number): number {
+    return MathUtils.degToRad(degrees);
+}

package/src/math/index.ts

@@ -4,6 +4,8 @@ import roundExp from './round/roundExp.ts';
 import signedAngleTo from './signedAngleTo/signedAngleTo.ts';
 import toFixedExp from './toFixed/toFixedExp.ts';
 import truncateExp from './truncate/truncateExp.ts';
+import radToDeg from './radToDeg/radToDeg.ts';
+import degToRad from './degToRad/degToRad.ts';
 
 export const DIVEMath: {
     ceilExp: typeof ceilExp;
@@ -12,6 +14,8 @@ export const DIVEMath: {
     toFixedExp: typeof toFixedExp;
     truncateExp: typeof truncateExp;
     signedAngleTo: typeof signedAngleTo;
+    radToDeg: typeof radToDeg;
+    degToRad: typeof degToRad;
 } = {
     ceilExp,
     floorExp,
@@ -19,4 +23,6 @@ export const DIVEMath: {
     toFixedExp,
     truncateExp,
     signedAngleTo,
+    radToDeg,
+    degToRad,
 };

package/src/math/radToDeg/__test__/radToDeg.test.ts

@@ -0,0 +1,162 @@
+import radToDeg from '../radToDeg';
+import { MathUtils } from 'three';
+
+// Mock the 'three' module, specifically MathUtils.radToDeg
+jest.mock('three', () => ({
+    MathUtils: {
+        radToDeg: jest.fn(),
+    },
+}));
+
+// Type assertion for the mocked MathUtils.radToDeg
+const mockedRadToDeg = MathUtils.radToDeg as jest.Mock;
+
+/**
+ * Test Suite for radToDeg Function
+ */
+describe('radToDeg', () => {
+    beforeEach(() => {
+        // Clear all previous mock calls and implementations before each test
+        mockedRadToDeg.mockClear();
+    });
+
+    it('should convert 0 radians to 0 degrees', () => {
+        // Arrange
+        mockedRadToDeg.mockReturnValue(0);
+
+        // Act
+        const result = radToDeg(0);
+
+        // Assert
+        expect(MathUtils.radToDeg).toHaveBeenCalledWith(0);
+        expect(result).toBe(0);
+    });
+
+    it('should convert π radians to 180 degrees', () => {
+        // Arrange
+        const pi = Math.PI;
+        mockedRadToDeg.mockReturnValue(180);
+
+        // Act
+        const result = radToDeg(pi);
+
+        // Assert
+        expect(MathUtils.radToDeg).toHaveBeenCalledWith(pi);
+        expect(result).toBe(180);
+    });
+
+    it('should convert 2π radians to 0 degrees (wrapped)', () => {
+        // Arrange
+        const twoPi = 2 * Math.PI;
+        mockedRadToDeg.mockReturnValue(360);
+
+        // Act
+        const result = radToDeg(twoPi);
+
+        // Assert
+        expect(MathUtils.radToDeg).toHaveBeenCalledWith(twoPi);
+        expect(result).toBe(0);
+    });
+
+    it('should convert 3π/2 radians to 270 degrees', () => {
+        // Arrange
+        const threePiOver2 = (3 * Math.PI) / 2;
+        mockedRadToDeg.mockReturnValue(270);
+
+        // Act
+        const result = radToDeg(threePiOver2);
+
+        // Assert
+        expect(MathUtils.radToDeg).toHaveBeenCalledWith(threePiOver2);
+        expect(result).toBe(270);
+    });
+
+    it('should handle angles greater than 2π radians correctly', () => {
+        // Arrange
+        const sevenPi = 7 * Math.PI; // 1260 degrees
+        const expectedDegrees = (1260 + 360) % 360; // 180 degrees
+        mockedRadToDeg.mockReturnValue(1260);
+
+        // Act
+        const result = radToDeg(sevenPi);
+
+        // Assert
+        expect(MathUtils.radToDeg).toHaveBeenCalledWith(sevenPi);
+        expect(result).toBe(expectedDegrees);
+    });
+
+    it('should handle fractional radians correctly', () => {
+        // Arrange
+        const fractionalRadians = Math.PI / 4; // 45 degrees
+        mockedRadToDeg.mockReturnValue(45);
+
+        // Act
+        const result = radToDeg(fractionalRadians);
+
+        // Assert
+        expect(MathUtils.radToDeg).toHaveBeenCalledWith(fractionalRadians);
+        expect(result).toBe(45);
+    });
+
+    it('should wrap negative angles correctly', () => {
+        // Since the function does not handle negative inputs, this test ensures it behaves as expected
+        // However, based on initial requirements, negative degrees are not allowed and inputs are non-negative
+        // This test is optional and based on how you want the function to behave
+        const negativeRadians = -Math.PI / 2; // -90 degrees
+        mockedRadToDeg.mockReturnValue(-90);
+        const expectedDegrees = (-90 + 360) % 360; // 270 degrees
+
+        const result = radToDeg(negativeRadians);
+
+        expect(MathUtils.radToDeg).toHaveBeenCalledWith(negativeRadians);
+        expect(result).toBe(expectedDegrees);
+    });
+
+    it('should handle multiple full rotations correctly', () => {
+        // Arrange
+        const multipleRotations = 5 * 2 * Math.PI; // 360 * 5 = 1800 degrees
+        const expectedDegrees = (1800 + 360) % 360; // 0 degrees
+        mockedRadToDeg.mockReturnValue(1800);
+
+        // Act
+        const result = radToDeg(multipleRotations);
+
+        // Assert
+        expect(MathUtils.radToDeg).toHaveBeenCalledWith(multipleRotations);
+        expect(result).toBe(0);
+    });
+
+    it('should handle mixed angles', () => {
+        // Arrange
+        const angles = [
+            Math.PI / 6,
+            Math.PI,
+            (5 * Math.PI) / 3,
+        ];
+        const mockReturns = [
+            30,
+            180,
+            300,
+        ];
+        const expectedDegrees = [
+            (30 + 360) % 360,
+            (180 + 360) % 360,
+            (300 + 360) % 360,
+        ]; // [30, 180, 300]
+
+        mockedRadToDeg
+            .mockReturnValueOnce(mockReturns[0])
+            .mockReturnValueOnce(mockReturns[1])
+            .mockReturnValueOnce(mockReturns[2]);
+
+        // Act & Assert for each angle
+        angles.forEach((angle, index) => {
+            const result = radToDeg(angle);
+            expect(MathUtils.radToDeg).toHaveBeenNthCalledWith(
+                index + 1,
+                angle,
+            );
+            expect(result).toBe(expectedDegrees[index]);
+        });
+    });
+});

package/src/math/radToDeg/radToDeg.ts

@@ -0,0 +1,5 @@
+import { MathUtils } from 'three';
+
+export default function radToDeg(radians: number): number {
+    return (MathUtils.radToDeg(radians) + 360) % 360;
+}

package/src/node/Node.ts

@@ -67,6 +67,9 @@ export class DIVENode extends Object3D implements DIVESelectable, DIVEMovable {
         );
     }
 
+    /**
+     * Can be called when the object is moved from a foreign object (gizmo, parent, etc.) to update the object's position.
+     */
     public onMove(): void {
         DIVECommunication.get(this.userData.id)?.PerformAction(
             'UPDATE_OBJECT',