@shopware-ag/dive 1.16.2 → 1.16.4

package/package.json

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

package/src/com/Communication.ts

@@ -292,6 +292,11 @@ export class DIVECommunication {
                 );
                 break;
             }
+            default: {
+                console.warn(
+                    `DIVECommunication.PerformAction: has been executed with unknown Action type ${action}`,
+                );
+            }
         }
 
         this.dispatch(action, payload);

package/src/com/__test__/Communication.test.ts

@@ -1,6 +1,6 @@
 import { DIVECommunication } from '../Communication';
 import '../types';
-import '../actions';
+import { type Actions } from '../actions';
 import '../actions/camera/movecamera';
 import '../actions/camera/resetcamera';
 import '../actions/camera/setcameralayer';
@@ -933,4 +933,10 @@ describe('dive/communication/DIVECommunication', () => {
         });
         expect(result).toBe(url);
     });
+
+    it('should warn of action is of invalid type ', () => {
+        jest.spyOn(console, 'warn').mockImplementationOnce(() => {});
+        testCom.PerformAction('INVALID_ACTION' as keyof Actions, {});
+        expect(console.warn).toHaveBeenCalledTimes(1);
+    });
 });

package/src/com/types/COMGeometry.ts

@@ -1,5 +1,7 @@
+import { COMGeometryType } from './COMGeometryType';
+
 export type COMGeometry = {
-    name: string;
+    name: COMGeometryType;
     width: number;
     height: number;
     depth: number;

package/src/com/types/COMGeometryType.ts

@@ -0,0 +1,9 @@
+export type COMGeometryType =
+    | 'cylinder'
+    | 'sphere'
+    | 'pyramid'
+    | 'cube'
+    | 'box'
+    | 'cone'
+    | 'wall'
+    | 'plane';

package/src/com/types/index.ts

@@ -7,6 +7,7 @@ import { type COMGeometry } from './COMGeometry';
 import { type COMMaterial } from './COMMaterial';
 import { type COMGroup } from './COMGroup';
 import { type COMEntityType } from './COMEntityType';
+import { type COMGeometryType } from './COMGeometryType';
 
 export type {
     COMEntity,
@@ -18,4 +19,5 @@ export type {
     COMMaterial,
     COMGroup,
     COMEntityType,
+    COMGeometryType,
 };

package/src/io/IO.ts

@@ -18,63 +18,40 @@ export class DIVEIO {
         type: FileType,
         url: string,
     ): Promise<DIVESceneFileType[FileType] | null> {
-        return this._importFromURL(type, url)
-
-            .catch((error) => {
-                console.error(error);
-
-                return null;
-            });
-    }
-
-    public Export<FileType extends keyof DIVESceneFileType>(
-        type: FileType,
-    ): Promise<string | null> {
-        return this._exportToURL(type)
-
-            .catch((error) => {
-                console.error(error);
-
-                return null;
-            });
-    }
-
-    private _importFromURL<FileType extends keyof DIVESceneFileType>(
-        type: FileType,
-        url: string,
-    ): Promise<DIVESceneFileType[FileType]> {
         switch (type) {
             case 'glb': {
-                return this._gltfIO.Import(url);
+                return this._gltfIO.Import(url).catch((error) => {
+                    console.error(error);
+                    return null;
+                });
             }
 
             default: {
-                return Promise.reject('Unsupported file type: ' + type);
+                console.error('DIVEIO.Import: Unsupported file type: ' + type);
+                return Promise.reject();
             }
         }
     }
 
-    private _exportToURL<FileType extends keyof DIVESceneFileType>(
+    public Export<FileType extends keyof DIVESceneFileType>(
         type: FileType,
-    ): Promise<string> {
+    ): Promise<string | null> {
         switch (type) {
             case 'glb': {
-                return new Promise((resolve, reject) => {
-                    this._gltfIO
-                        .Export(this._scene, true, true)
-
-                        .then((data) => {
-                            resolve(this._createBlobURL(data));
-                        })
-
-                        .catch((error) => {
-                            reject(error);
-                        });
-                });
+                return this._gltfIO
+                    .Export(this._scene, true, true)
+                    .then((data) => {
+                        return this._createBlobURL(data);
+                    })
+                    .catch((error) => {
+                        console.error(error);
+                        return null;
+                    });
             }
 
             default: {
-                return Promise.reject('Unsupported file type: ' + type);
+                console.error('DIVEIO.Export: Unsupported file type: ' + type);
+                return Promise.reject();
             }
         }
     }

package/src/io/__test__/IO.test.ts

@@ -58,15 +58,24 @@ describe('dive/io/DIVEIO', () => {
         expect(result).toStrictEqual(mockGLTF);
     });
 
-    it('should reject when importing with unsupported file type', async () => {
+    it('should handle rejection from gltf io import', async () => {
         jest.spyOn(console, 'error').mockImplementationOnce(() => {});
-
-        const result = await testIO.Import(
-            'unsupported file type' as 'glb',
-            'test.glb',
+        jest.spyOn(testIO['_gltfIO'], 'Import').mockRejectedValueOnce(
+            'THIS_IS_A_TEST_ERROR',
         );
 
-        expect(result).toStrictEqual(null);
+        expect(testIO.Import('glb', 'test.glb')).resolves.toEqual(null);
+    });
+
+    it('should reject when importing with unsupported file type', async () => {
+        const spy = jest
+            .spyOn(console, 'error')
+            .mockImplementationOnce(() => {});
+
+        expect(
+            testIO.Import('THIS_IS_NOT_A_VALID_FILE_TYPE' as 'glb', 'test.glb'),
+        ).rejects.not.toBeDefined();
+        expect(spy).toHaveBeenCalled();
     });
 
     it('should export to URL', async () => {
@@ -80,20 +89,28 @@ describe('dive/io/DIVEIO', () => {
 
         const result = await testIO.Export('glb');
         expect(result).toBeDefined();
+        expect(console.error).not.toHaveBeenCalled();
     });
 
-    it('should handle rejection from gltf io', async () => {
-        jest.spyOn(console, 'error').mockImplementationOnce(() => {});
-        jest.spyOn(testIO['_gltfIO'], 'Export').mockRejectedValueOnce('Error');
+    it('should handle rejection from gltf io export', async () => {
+        const spy = jest
+            .spyOn(console, 'error')
+            .mockImplementationOnce(() => {});
+        jest.spyOn(testIO['_gltfIO'], 'Export').mockRejectedValueOnce(
+            'THIS_IS_A_TEST_ERROR',
+        );
 
-        const result = await testIO.Export('glb');
-        expect(result).toBeDefined();
+        expect(testIO.Export('glb')).resolves.toEqual(null);
     });
 
     it('should reject when exporting with unsupported file type', async () => {
-        jest.spyOn(console, 'error').mockImplementationOnce(() => {});
-
-        const result = await testIO.Export('unsupported file type' as 'glb');
-        expect(result).toStrictEqual(null);
+        const spy = jest
+            .spyOn(console, 'error')
+            .mockImplementationOnce(() => {});
+
+        expect(
+            testIO.Export('THIS_IS_NOT_A_VALID_FILE_TYPE' as 'glb'),
+        ).rejects.not.toBeDefined();
+        expect(spy).toHaveBeenCalled();
     });
 });

package/src/primitive/Primitive.ts

@@ -43,7 +43,10 @@ export class DIVEPrimitive extends DIVENode {
     }
 
     public SetGeometry(geometry: COMGeometry): void {
-        this._mesh.geometry = this.assembleGeometry(geometry);
+        const geo = this.assembleGeometry(geometry);
+        if (!geo) return;
+
+        this._mesh.geometry = geo;
         this._boundingBox.setFromObject(this._mesh);
     }
 
@@ -168,7 +171,7 @@ export class DIVEPrimitive extends DIVENode {
         }
     }
 
-    private assembleGeometry(geometry: COMGeometry): BufferGeometry {
+    private assembleGeometry(geometry: COMGeometry): BufferGeometry | null {
         switch (geometry.name.toLowerCase()) {
             case 'cylinder':
                 return this.createCylinderGeometry(geometry);
@@ -176,6 +179,7 @@ export class DIVEPrimitive extends DIVENode {
                 return this.createSphereGeometry(geometry);
             case 'pyramid':
                 return this.createPyramidGeometry(geometry);
+            case 'cube':
             case 'box':
                 return this.createBoxGeometry(geometry);
             case 'cone':
@@ -186,10 +190,10 @@ export class DIVEPrimitive extends DIVENode {
                 return this.createPlaneGeometry(geometry);
             default: {
                 console.warn(
-                    'DIVEPrimitive: Invalid geometry type:',
+                    'DIVEPrimitive.assembleGeometry: Invalid geometry type:',
                     geometry.name.toLowerCase(),
                 );
-                return new BufferGeometry();
+                return null;
             }
         }
     }

package/src/primitive/__test__/Primitive.test.ts

@@ -8,7 +8,11 @@ import {
     type MeshStandardMaterial,
 } from 'three';
 import type { DIVEScene } from '../../scene/Scene';
-import { type COMMaterial, type COMGeometry } from '../../com/types';
+import {
+    type COMMaterial,
+    type COMGeometry,
+    type COMGeometryType,
+} from '../../com/types';
 
 const intersectObjectsMock = jest.fn();
 
@@ -219,10 +223,21 @@ describe('dive/primitive/DIVEPrimitive', () => {
     });
 
     it('should set geometry', () => {
+        jest.spyOn(console, 'warn');
+        const geometry = {
+            name: 'cube' as COMGeometryType,
+        } as COMGeometry;
+        expect(() => primitive.SetGeometry(geometry)).not.toThrow();
+        expect(console.warn).not.toHaveBeenCalled();
+    });
+
+    it('should warn when geometry is invalid', () => {
+        jest.spyOn(console, 'warn').mockImplementation(() => {});
         const geometry = {
-            name: 'geometry',
+            name: 'INVALID' as COMGeometryType,
         } as COMGeometry;
         expect(() => primitive.SetGeometry(geometry)).not.toThrow();
+        expect(console.warn).toHaveBeenCalled();
     });
 
     it('should place on floor', () => {

package/src/renderer/__test__/Renderer.test.ts

@@ -10,7 +10,6 @@ const test_uuid = 'test-uuid';
 
 const mock_render = jest.fn();
 const mock_setSize = jest.fn();
-const mock_setAnimationLoop = jest.fn();
 
 jest.mock('three', () => {
     return {
@@ -27,7 +26,9 @@ jest.mock('three', () => {
             this.setSize = mock_setSize;
             this.setPixelRatio = jest.fn();
             this.render = mock_render;
-            this.setAnimationLoop = mock_setAnimationLoop;
+            this.setAnimationLoop = jest.fn((callback: (() => void) | null) => {
+                if (callback) callback();
+            });
             this.shadowMap = {
                 enabled: false,
             };

package/src/scene/root/Root.ts

@@ -81,6 +81,11 @@ export class DIVERoot extends Object3D {
                 this.updateGroup(object);
                 break;
             }
+            default: {
+                console.warn(
+                    `DIVERoot.AddSceneObject: Unknown entity type: ${object.entityType}`,
+                );
+            }
         }
     }
 
@@ -107,6 +112,11 @@ export class DIVERoot extends Object3D {
                 this.updateGroup(object);
                 break;
             }
+            default: {
+                console.warn(
+                    `DIVERoot.UpdateSceneObject: Unknown entity type: ${object.entityType}`,
+                );
+            }
         }
     }
 
@@ -133,6 +143,11 @@ export class DIVERoot extends Object3D {
                 this.deleteGroup(object);
                 break;
             }
+            default: {
+                console.warn(
+                    `DIVERoot.DeleteSceneObject: Unknown entity type: ${object.entityType}`,
+                );
+            }
         }
     }
 
@@ -147,6 +162,11 @@ export class DIVERoot extends Object3D {
                 this.placeOnFloor(object);
                 break;
             }
+            default: {
+                console.warn(
+                    `DIVERoot.PlaceOnFloor: Unknown entity type: ${object.entityType}`,
+                );
+            }
         }
     }
 

package/src/scene/root/__test__/Root.test.ts

@@ -6,7 +6,8 @@ import {
     type COMPov,
     type COMEntity,
     type COMGeometry,
-    COMGroup,
+    type COMGroup,
+    type COMEntityType,
 } from '../../../com/types';
 import { type DIVEScene } from '../../Scene';
 import { DIVECommunication } from '../../../com/Communication';
@@ -928,4 +929,56 @@ describe('DIVE/scene/root/DIVERoot', () => {
             } as COMPrimitive),
         ).not.toThrow();
     });
+
+    it('should warn if entity type is invalid while adding object', () => {
+        const spy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+        expect(() =>
+            root.AddSceneObject({
+                id: 'id',
+                name: 'entity',
+                entityType: 'INVALID' as COMEntityType,
+                visible: true,
+            } as COMEntity),
+        ).not.toThrow();
+        expect(spy).toHaveBeenCalled();
+    });
+
+    it('should warn if entity type is invalid while updating object', () => {
+        const spy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+        expect(() =>
+            root.UpdateSceneObject({
+                id: 'id',
+                name: 'entity',
+                entityType: 'INVALID' as COMEntityType,
+                visible: true,
+            } as COMEntity),
+        ).not.toThrow();
+        expect(spy).toHaveBeenCalled();
+    });
+
+    it('should warn if entity type is invalid while deleting object', () => {
+        const spy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+        expect(() =>
+            root.DeleteSceneObject({
+                id: 'id',
+                name: 'entity',
+                entityType: 'INVALID' as COMEntityType,
+                visible: true,
+            } as COMEntity),
+        ).not.toThrow();
+        expect(spy).toHaveBeenCalled();
+    });
+
+    it('should warn if entity type is invalid while placing on floor', () => {
+        const spy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+        expect(() =>
+            root.PlaceOnFloor({
+                id: 'id',
+                name: 'entity',
+                entityType: 'INVALID' as COMEntityType,
+                visible: true,
+            } as COMEntity),
+        ).not.toThrow();
+        expect(spy).toHaveBeenCalled();
+    });
 });

package/src/toolbox/BaseTool.ts

@@ -95,15 +95,23 @@ export abstract class DIVEBaseTool {
 
     public onPointerDown(e: PointerEvent): void {
         switch (e.button) {
-            case 0:
+            case 0: {
                 this._pointerPrimaryDown = true;
                 break;
-            case 1:
+            }
+            case 1: {
                 this._pointerMiddleDown = true;
                 break;
-            case 2:
+            }
+            case 2: {
                 this._pointerSecondaryDown = true;
                 break;
+            }
+            default: {
+                console.warn(
+                    'DIVEBaseTool.onPointerDown: Unknown button: ' + e.button,
+                );
+            }
         }
 
         this._lastPointerDown.copy(this._pointer);

package/src/toolbox/Toolbox.ts

@@ -66,7 +66,7 @@ export default class DIVEToolbox {
                 break;
             }
             default: {
-                throw new Error(`ToolBox.UseTool: Unknown tool: ${tool}`);
+                console.warn(`DIVEToolBox.UseTool: Unknown tool: ${tool}`);
             }
         }
     }

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

@@ -1,7 +1,7 @@
 import { DIVEBaseTool } from '../BaseTool';
 import type DIVEOrbitControls from '../../controls/OrbitControls';
 import type { DIVEScene } from '../../scene/Scene';
-import { type Object3D, type Vector3 } from 'three';
+import { type Intersection, type Object3D, type Vector3 } from 'three';
 import { type DIVEHoverable } from '../../interface/Hoverable';
 import { type DIVEDraggable } from '../../interface/Draggable';
 
@@ -60,8 +60,36 @@ describe('dive/toolbox/DIVEBaseTool', () => {
 
     it('should raycast', () => {
         const toolBox = new abstractWrapper(mockScene, mockController);
+        const spy = jest
+            .spyOn(toolBox['_raycaster'], 'intersectObjects')
+            .mockImplementationOnce(() => {
+                return [
+                    {
+                        object: {
+                            visible: true,
+                        },
+                    } as unknown as Intersection,
+                ];
+            });
         expect(() => toolBox['raycast']()).not.toThrow();
+        expect(spy).toHaveBeenCalled();
+    });
+
+    it('should raycast with selection of objects', () => {
+        const toolBox = new abstractWrapper(mockScene, mockController);
+        const spy = jest
+            .spyOn(toolBox['_raycaster'], 'intersectObjects')
+            .mockImplementationOnce(() => {
+                return [
+                    {
+                        object: {
+                            visible: true,
+                        },
+                    } as unknown as Intersection,
+                ];
+            });
         expect(() => toolBox['raycast']([])).not.toThrow();
+        expect(spy).toHaveBeenCalled();
     });
 
     it('should return correct pointerAnyDown', () => {
@@ -96,13 +124,21 @@ describe('dive/toolbox/DIVEBaseTool', () => {
         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();
 
+        const spy = jest.spyOn(console, 'warn').mockImplementation();
+        expect(() =>
+            toolBox.onPointerDown({ button: 666 } as PointerEvent),
+        ).not.toThrow();
+        expect(spy).toHaveBeenCalled();
+
         toolBox['_intersects'] = [
             {
                 distance: 1,

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

@@ -6,21 +6,6 @@ import type { DIVEScene } from '../../scene/Scene';
  * @jest-environment jsdom
  */
 
-const mock_addEventListener = jest.fn();
-const mock_removeEventListener = jest.fn();
-
-const mock_Canvas = {
-    width: 0,
-    height: 0,
-    addEventListener: mock_addEventListener,
-    getContext: jest.fn(),
-    removeEventListener: mock_removeEventListener,
-    clientWidth: 0,
-    clientHeight: 0,
-    offsetLeft: 0,
-    offsetTop: 0,
-};
-
 jest.mock('../select/SelectTool.ts', () => {
     return {
         DIVESelectTool: jest.fn(function () {
@@ -38,7 +23,21 @@ jest.mock('../select/SelectTool.ts', () => {
 });
 
 const mockController = {
-    domElement: mock_Canvas,
+    domElement: {
+        width: 0,
+        height: 0,
+        addEventListener: jest.fn((type, callback) => {
+            callback();
+        }),
+        getContext: jest.fn(),
+        removeEventListener: jest.fn((type, callback) => {
+            callback();
+        }),
+        clientWidth: 0,
+        clientHeight: 0,
+        offsetLeft: 0,
+        offsetTop: 0,
+    },
     object: {},
 } as unknown as DIVEOrbitControls;
 
@@ -55,14 +54,15 @@ describe('dive/toolbox/DIVEToolBox', () => {
     it('should dispose', () => {
         const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
         toolBox.Dispose();
-        expect(mock_removeEventListener).toHaveBeenCalled();
     });
 
     it('should throw with incorrect tool', () => {
+        const spy = jest.spyOn(console, 'warn').mockImplementation();
         const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
         expect(() =>
             toolBox.UseTool('not a real tool' as unknown as ToolType),
-        ).toThrow();
+        ).not.toThrow();
+        expect(spy).toHaveBeenCalled();
     });
 
     it('should use no tool', () => {