@shopware-ag/dive 1.16.7 → 1.16.9

package/package.json

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

package/src/com/actions/scene/getallscenedata.ts

@@ -1,30 +1,7 @@
-import { Vector3Like } from 'three';
-import {
-    type COMLight,
-    type COMModel,
-    type COMPov,
-    type COMPrimitive,
-} from '../../types';
-
-type SceneData = {
-    name: string;
-    mediaItem: null;
-    backgroundColor: string;
-    floorEnabled: boolean;
-    floorColor: string;
-    userCamera: {
-        position: Vector3Like;
-        target: Vector3Like;
-    };
-    spotmarks: object[];
-    lights: COMLight[];
-    objects: COMModel[];
-    cameras: COMPov[];
-    primitives: COMPrimitive[];
-};
+import { DIVESceneData } from '../../../types';
 
 export default interface GET_ALL_SCENE_DATA {
     DESCRIPTION: 'Retrieves all current scene data.';
     PAYLOAD: object;
-    RETURN: SceneData;
+    RETURN: DIVESceneData;
 }

package/src/com/types/COMLight.ts

@@ -7,4 +7,5 @@ export type COMLight = COMBaseEntity & {
     color: string | number;
     enabled: boolean;
     position?: Vector3Like;
+    rotation?: Vector3Like;
 };

package/src/dive.ts

@@ -329,3 +329,4 @@ export * from './math/index.ts';
 
 export type * from './com/actions/index.ts';
 export type * from './com/types';
+export type * from './types';

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/model/Model.ts

@@ -4,6 +4,7 @@ import type { GLTF } from 'three/examples/jsm/Addons.js';
 import { findSceneRecursive } from '../helper/findSceneRecursive/findSceneRecursive';
 import { type COMMaterial } from '../com/types';
 import { DIVENode } from '../node/Node';
+import { DIVECommunication } from '../com/Communication';
 
 /**
  * A basic model class.
@@ -23,6 +24,7 @@ export class DIVEModel extends DIVENode {
 
     public SetModel(gltf: GLTF): void {
         this.clear();
+        this._boundingBox.makeEmpty();
 
         gltf.scene.traverse((child) => {
             child.castShadow = true;
@@ -110,11 +112,25 @@ export class DIVEModel extends DIVENode {
     }
 
     public PlaceOnFloor(): void {
-        const oldPos = this.position.clone();
-        this.position.y = -this._boundingBox.min.y * this.scale.y;
-        if (this.position.y === oldPos.y) return;
-
-        this.onMove();
+        // calculate and temporary save world position
+        const worldPos = this.getWorldPosition(this._positionWorldBuffer);
+        const oldWorldPos = worldPos.clone();
+
+        // calculate the bottom center of the bounding box and set it to world posion
+        worldPos.y = -this._boundingBox.min.y * this.scale.y;
+
+        // skip any action when the position did not change
+        if (worldPos.y === oldWorldPos.y) return;
+
+        DIVECommunication.get(this.userData.id)?.PerformAction(
+            'UPDATE_OBJECT',
+            {
+                id: this.userData.id,
+                position: worldPos,
+                rotation: this.rotation,
+                scale: this.scale,
+            },
+        );
     }
 
     public DropIt(): void {

package/src/model/__test__/Model.test.ts

@@ -11,12 +11,17 @@ import {
     Color,
 } from 'three';
 import { type COMMaterial } from '../../com/types';
+import { isTypeOnlyImportOrExportDeclaration } from 'typescript';
 
 const intersectObjectsMock = jest.fn();
 
 jest.mock('three', () => {
     return {
-        Vector3: jest.fn(function (x: number, y: number, z: number) {
+        Vector3: jest.fn(function (
+            x: number = 0,
+            y: number = 0,
+            z: number = 0,
+        ) {
             this.x = x;
             this.y = y;
             this.z = z;
@@ -107,6 +112,9 @@ jest.mock('three', () => {
             this.traverse = jest.fn((callback) => {
                 callback(this.children[0]);
             });
+            this.getWorldPosition = jest.fn(() => {
+                return this.position.clone();
+            });
             return this;
         }),
         Box3: jest.fn(function () {
@@ -116,6 +124,7 @@ jest.mock('three', () => {
                 return new Vector3(0, 0, 0);
             });
             this.expandByObject = jest.fn();
+            this.makeEmpty = jest.fn();
 
             return this;
         }),
@@ -226,16 +235,37 @@ describe('dive/model/DIVEModel', () => {
     });
 
     it('should place on floor', () => {
+        const com = DIVECommunication.get('id')!;
+        const spyPerformAction = jest.spyOn(com, 'PerformAction');
+
         model.userData.id = 'something';
 
-        const spy = jest.spyOn(model, 'onMove').mockImplementation(() => {});
+        model['_boundingBox'] = {
+            min: new Vector3(0, -1, 0),
+        } as unknown as Box3;
 
         expect(() => model.PlaceOnFloor()).not.toThrow();
-        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spyPerformAction).toHaveBeenCalledWith(
+            'UPDATE_OBJECT',
+            expect.objectContaining({
+                position: expect.objectContaining({
+                    y: 1,
+                }),
+            }),
+        );
 
+        // skip any action when the position did not change
+        spyPerformAction.mockClear();
+        model.position.y = 1;
+        expect(() => model.PlaceOnFloor()).not.toThrow();
+        expect(spyPerformAction).not.toHaveBeenCalled();
+
+        // mock that the communication is not available
+        spyPerformAction.mockClear();
         jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
+        model.position.y = 0;
         expect(() => model.PlaceOnFloor()).not.toThrow();
-        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spyPerformAction).not.toHaveBeenCalled();
     });
 
     it('should drop it', () => {