@shopware-ag/dive 1.16.0 → 1.16.2

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

@@ -4,142 +4,96 @@ import { DIVEScene } from '../../scene/Scene';
 import { type GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
 
 jest.mock('../gltf/GLTFIO', () => {
-
     return {
-
         DIVEGLTFIO: jest.fn(function () {
-
             this.Import = jest.fn();
-
             this.Export = jest.fn();
-
             return this;
-
-        })
-
+        }),
     };
-
 });
 
 jest.mock('../../scene/Scene.ts', () => {
-
     return {
-
         DIVEScene: jest.fn(function () {
-
             this.add = jest.fn();
-
             this.isObject3D = true;
-
             this.parent = null;
-
             this.dispatchEvent = jest.fn();
-
             this.position = {
-
                 set: jest.fn(),
-
-            }
-
+            };
             this.SetIntensity = jest.fn();
-
             this.SetEnabled = jest.fn();
-
             this.SetColor = jest.fn();
-
             this.userData = {
-
                 id: undefined,
-
-            }
-
+            };
             this.removeFromParent = jest.fn();
-
             return this;
-        })
-
+        }),
     };
-
 });
 
 let testIO: DIVEIO;
 
 describe('dive/io/DIVEIO', () => {
     beforeEach(() => {
-
         testIO = new DIVEIO(new DIVEScene());
-
     });
 
     afterEach(() => {
-
         jest.clearAllMocks();
-
     });
 
     it('should instantiate', () => {
-
         expect(testIO).toBeDefined();
-
     });
 
     it('should import from URL', async () => {
-
         const mockGLTF = {} as GLTF;
-
         jest.spyOn(testIO['_gltfIO'], 'Import').mockResolvedValueOnce(mockGLTF);
 
         const result = await testIO.Import('glb', 'test.glb');
-
         expect(result).toStrictEqual(mockGLTF);
-
     });
 
     it('should reject when importing with unsupported file type', async () => {
+        jest.spyOn(console, 'error').mockImplementationOnce(() => {});
 
-        jest.spyOn(console, 'error').mockImplementationOnce(() => { });
-
-        const result = await testIO.Import('unsupported file type' as "glb", 'test.glb');
+        const result = await testIO.Import(
+            'unsupported file type' as 'glb',
+            'test.glb',
+        );
 
         expect(result).toStrictEqual(null);
-
     });
 
     it('should export to URL', async () => {
-
         const mockObject = {};
-
         const mockURL = 'blob://mockURL';
-
-        jest.spyOn(testIO['_gltfIO'], 'Export').mockResolvedValueOnce(mockObject);
+        jest.spyOn(testIO['_gltfIO'], 'Export').mockResolvedValueOnce(
+            mockObject,
+        );
 
         URL.createObjectURL = jest.fn().mockReturnValueOnce(mockURL);
 
         const result = await testIO.Export('glb');
-
         expect(result).toBeDefined();
-
     });
 
     it('should handle rejection from gltf io', async () => {
-
-        jest.spyOn(console, 'error').mockImplementationOnce(() => { });
-
+        jest.spyOn(console, 'error').mockImplementationOnce(() => {});
         jest.spyOn(testIO['_gltfIO'], 'Export').mockRejectedValueOnce('Error');
 
         const result = await testIO.Export('glb');
-
         expect(result).toBeDefined();
-
     });
 
     it('should reject when exporting with unsupported file type', async () => {
+        jest.spyOn(console, 'error').mockImplementationOnce(() => {});
 
-        jest.spyOn(console, 'error').mockImplementationOnce(() => { });
-
-        const result = await testIO.Export('unsupported file type' as "glb");
-
+        const result = await testIO.Export('unsupported file type' as 'glb');
         expect(result).toStrictEqual(null);
-
     });
-});
+});

package/src/io/gltf/GLTFIO.ts

@@ -1,53 +1,56 @@
-import { GLTFLoader, type GLTF } from "three/examples/jsm/loaders/GLTFLoader";
-import { GLTFExporter } from "three/examples/jsm/exporters/GLTFExporter";
-import { Object3D } from "three";
+import { GLTFLoader, type GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter';
+import { Object3D } from 'three';
 
 export class DIVEGLTFIO {
-
     private _importer: GLTFLoader;
-
     private _exporter: GLTFExporter;
 
     constructor() {
-
         this._importer = new GLTFLoader();
-
         this._exporter = new GLTFExporter();
-
     }
 
-    public Import(url: string, onProgress?: (progress: number) => void): Promise<GLTF> {
-
+    public Import(
+        url: string,
+        onProgress?: (progress: number) => void,
+    ): Promise<GLTF> {
         return this._importer.loadAsync(url, (progress) => {
-
             if (!onProgress) return;
 
             onProgress(progress.loaded / progress.total);
-
         });
-
     }
 
-    public Export(object: Object3D, binary: true, onlyVisible: boolean): Promise<ArrayBuffer>;
-
-    public Export(object: Object3D, binary: false, onlyVisible: boolean): Promise<{ [key: string]: unknown }>;
-
-    public Export(object: Object3D, binary: boolean, onlyVisible: boolean): Promise<ArrayBuffer | { [key: string]: unknown }> {
-
+    public Export(
+        object: Object3D,
+        binary: true,
+        onlyVisible: boolean,
+    ): Promise<ArrayBuffer>;
+
+    public Export(
+        object: Object3D,
+        binary: false,
+        onlyVisible: boolean,
+    ): Promise<{ [key: string]: unknown }>;
+
+    public Export(
+        object: Object3D,
+        binary: boolean,
+        onlyVisible: boolean,
+    ): Promise<ArrayBuffer | { [key: string]: unknown }> {
         if (binary) {
-
             // export as binary ArrayBuffer
-
-            return this._exporter.parseAsync(object, { binary, onlyVisible }) as unknown as Promise<ArrayBuffer>;
-
+            return this._exporter.parseAsync(object, {
+                binary,
+                onlyVisible,
+            }) as unknown as Promise<ArrayBuffer>;
         } else {
-
             // export as JSON object
-
-            return this._exporter.parseAsync(object, { binary, onlyVisible }) as unknown as Promise<{ [key: string]: unknown; }>;
-
+            return this._exporter.parseAsync(object, {
+                binary,
+                onlyVisible,
+            }) as unknown as Promise<{ [key: string]: unknown }>;
         }
-
-    };
-
-}
+    }
+}

package/src/io/gltf/__test__/GLTFIO.test.ts

@@ -22,154 +22,164 @@ jest.mock('three', () => {
                     far: 0,
                     fov: 0,
                 },
-            }
+            };
             this.add = jest.fn();
             this.sub = jest.fn();
-            this.children = [{
-                visible: true,
-                material: {
-                    color: {},
+            this.children = [
+                {
+                    visible: true,
+                    material: {
+                        color: {},
+                    },
                 },
-            }];
+            ];
             this.userData = {};
             this.traverse = jest.fn((callback) => {
-                callback(this.children[0])
+                callback(this.children[0]);
             });
             return this;
         }),
-    }
+    };
 });
 
 jest.mock('three/examples/jsm/loaders/GLTFLoader', () => {
     return {
         GLTFLoader: jest.fn(function () {
-
-            this.loadAsync = (uri: string, progEvent: (p: ProgressEvent<EventTarget>) => void) => new Promise<void>((resolve) => {
-
-                progEvent({ loaded: 0, total: 1 } as ProgressEvent<EventTarget>);
-
-                resolve();
-
-            });
+            this.loadAsync = (
+                uri: string,
+                progEvent: (p: ProgressEvent<EventTarget>) => void,
+            ) =>
+                new Promise<void>((resolve) => {
+                    progEvent({
+                        loaded: 0,
+                        total: 1,
+                    } as ProgressEvent<EventTarget>);
+
+                    resolve();
+                });
 
             return this;
         }),
-    }
+    };
 });
 
 jest.mock('three/examples/jsm/exporters/GLTFExporter', () => {
-
     return {
-
         GLTFExporter: jest.fn(function () {
-
-            this.parseAsync = (object: Object3D, options?: GLTFExporterOptions) => new Promise<ArrayBuffer | { [key: string]: unknown }>((resolve) => {
-
-                resolve(new ArrayBuffer(0));
-
-            });
-
+            this.parseAsync = (
+                object: Object3D,
+                options?: GLTFExporterOptions,
+            ) =>
+                new Promise<ArrayBuffer | { [key: string]: unknown }>(
+                    (resolve) => {
+                        resolve(new ArrayBuffer(0));
+                    },
+                );
             return this;
-
-        })
-    }
-
+        }),
+    };
 });
 
 let testGLTFIO: DIVEGLTFIO;
 
 describe('dive/io/gltf/DIVEGLTFIO', () => {
     beforeEach(() => {
-
         testGLTFIO = new DIVEGLTFIO();
-
     });
 
     afterEach(() => {
-
         jest.clearAllMocks();
-
     });
 
     it('should instantiate', () => {
-
         expect(testGLTFIO).toBeDefined();
-
     });
 
     it('should import from URL', async () => {
-
         const mockGLTF = {} as GLTF;
 
-
-
         // test without progress callback
-
-        jest.spyOn(testGLTFIO['_importer'], 'loadAsync').mockImplementationOnce((uri: string, progEvent?: (p: ProgressEvent<EventTarget>) => void) => new Promise<GLTF>((resolve) => {
-
-            if (progEvent) progEvent({ loaded: 0, total: 1 } as ProgressEvent<EventTarget>);
-
-            resolve(mockGLTF);
-
-        }));
-
-        const resultWithoutProgress = await testGLTFIO.Import('test url', undefined);
+        jest.spyOn(testGLTFIO['_importer'], 'loadAsync').mockImplementationOnce(
+            (
+                uri: string,
+                progEvent?: (p: ProgressEvent<EventTarget>) => void,
+            ) =>
+                new Promise<GLTF>((resolve) => {
+                    if (progEvent)
+                        progEvent({
+                            loaded: 0,
+                            total: 1,
+                        } as ProgressEvent<EventTarget>);
+
+                    resolve(mockGLTF);
+                }),
+        );
+
+        const resultWithoutProgress = await testGLTFIO.Import(
+            'test url',
+            undefined,
+        );
 
         expect(resultWithoutProgress).toStrictEqual(mockGLTF);
 
-
-
         // test with progress callback
-
-        jest.spyOn(testGLTFIO['_importer'], 'loadAsync').mockImplementationOnce((uri: string, progEvent?: (p: ProgressEvent<EventTarget>) => void) => new Promise<GLTF>((resolve) => {
-
-            if (progEvent) progEvent({ loaded: 0, total: 1 } as ProgressEvent<EventTarget>);
-
-            resolve(mockGLTF);
-
-        }));
+        jest.spyOn(testGLTFIO['_importer'], 'loadAsync').mockImplementationOnce(
+            (
+                uri: string,
+                progEvent?: (p: ProgressEvent<EventTarget>) => void,
+            ) =>
+                new Promise<GLTF>((resolve) => {
+                    if (progEvent)
+                        progEvent({
+                            loaded: 0,
+                            total: 1,
+                        } as ProgressEvent<EventTarget>);
+
+                    resolve(mockGLTF);
+                }),
+        );
 
         const onProgress = jest.fn();
 
-        const resultWithProgress = await testGLTFIO.Import('test url', onProgress);
+        const resultWithProgress = await testGLTFIO.Import(
+            'test url',
+            onProgress,
+        );
 
         expect(resultWithProgress).toStrictEqual(mockGLTF);
-
         expect(onProgress).toHaveBeenCalledTimes(1);
-
     });
 
     it('should export to URL', async () => {
-
         const mockObject = new Object3D();
 
         // export as JSON object
-
-        jest.spyOn(testGLTFIO['_exporter'], 'parseAsync').mockResolvedValueOnce({});
+        jest.spyOn(testGLTFIO['_exporter'], 'parseAsync').mockResolvedValueOnce(
+            {},
+        );
 
         const json = await testGLTFIO.Export(mockObject, false, false);
-
         expect(json).toBeDefined();
 
-
-
         // export as array buffer
-
-        jest.spyOn(testGLTFIO['_exporter'], 'parseAsync').mockResolvedValueOnce(new ArrayBuffer(0));
+        jest.spyOn(testGLTFIO['_exporter'], 'parseAsync').mockResolvedValueOnce(
+            new ArrayBuffer(0),
+        );
 
         const binary = await testGLTFIO.Export(mockObject, true, false);
-
         expect(binary).toBeDefined();
 
-
-
         // export as array buffer (only visible)
 
-        jest.spyOn(testGLTFIO['_exporter'], 'parseAsync').mockResolvedValueOnce(new ArrayBuffer(0));
-
-        const binaryOnlyVisible = await testGLTFIO.Export(mockObject, true, true);
+        jest.spyOn(testGLTFIO['_exporter'], 'parseAsync').mockResolvedValueOnce(
+            new ArrayBuffer(0),
+        );
 
+        const binaryOnlyVisible = await testGLTFIO.Export(
+            mockObject,
+            true,
+            true,
+        );
         expect(binaryOnlyVisible).toBeDefined();
-
     });
-});
+});

package/src/light/PointLight.ts

@@ -1,6 +1,17 @@
-import { PointLight, Color, SphereGeometry, MeshBasicMaterial, Mesh, FrontSide, Object3D } from 'three';
+import {
+    PointLight,
+    Color,
+    SphereGeometry,
+    MeshBasicMaterial,
+    Mesh,
+    FrontSide,
+    Object3D,
+} from 'three';
 import { DIVECommunication } from '../com/Communication';
-import { PRODUCT_LAYER_MASK, UI_LAYER_MASK } from '../constant/VisibilityLayerMask';
+import {
+    PRODUCT_LAYER_MASK,
+    UI_LAYER_MASK,
+} from '../constant/VisibilityLayerMask';
 import { DIVEMovable } from '../interface/Movable';
 import { DIVESelectable } from '../interface/Selectable';
 import type { TransformControls } from 'three/examples/jsm/Addons.js';
@@ -15,7 +26,10 @@ import type { TransformControls } from 'three/examples/jsm/Addons.js';
  * @module
  */
 
-export default class DIVEPointLight extends Object3D implements DIVESelectable, DIVEMovable {
+export default class DIVEPointLight
+    extends Object3D
+    implements DIVESelectable, DIVEMovable
+{
     readonly isDIVELight: true = true;
     readonly isDIVEPointLight: true = true;
     readonly isMovable: true = true;
@@ -42,9 +56,18 @@ export default class DIVEPointLight extends Object3D implements DIVESelectable,
 
         const geoSize = 0.1;
 
-        const geometry = new SphereGeometry(geoSize, geoSize * 320, geoSize * 320);
+        const geometry = new SphereGeometry(
+            geoSize,
+            geoSize * 320,
+            geoSize * 320,
+        );
 
-        const material = new MeshBasicMaterial({ color: this.light.color, transparent: true, opacity: 0.8, side: FrontSide });
+        const material = new MeshBasicMaterial({
+            color: this.light.color,
+            transparent: true,
+            opacity: 0.8,
+            side: FrontSide,
+        });
 
         this.mesh = new Mesh(geometry, material);
         this.mesh.layers.mask = UI_LAYER_MASK;
@@ -61,7 +84,8 @@ export default class DIVEPointLight extends Object3D implements DIVESelectable,
     public SetIntensity(intensity: number): void {
         this.light.intensity = intensity;
 
-        (this.mesh.material as MeshBasicMaterial).opacity = intensity > 0.8 ? 0.8 : intensity * 0.8;
+        (this.mesh.material as MeshBasicMaterial).opacity =
+            intensity > 0.8 ? 0.8 : intensity * 0.8;
     }
 
     public SetEnabled(enabled: boolean): void {
@@ -69,14 +93,23 @@ export default class DIVEPointLight extends Object3D implements DIVESelectable,
     }
 
     public onMove(): void {
-        DIVECommunication.get(this.userData.id)?.PerformAction('UPDATE_OBJECT', { id: this.userData.id, position: this.position });
+        DIVECommunication.get(this.userData.id)?.PerformAction(
+            'UPDATE_OBJECT',
+            { id: this.userData.id, position: this.position },
+        );
     }
 
     public onSelect(): void {
-        DIVECommunication.get(this.userData.id)?.PerformAction('SELECT_OBJECT', { id: this.userData.id });
+        DIVECommunication.get(this.userData.id)?.PerformAction(
+            'SELECT_OBJECT',
+            { id: this.userData.id },
+        );
     }
 
     public onDeselect(): void {
-        DIVECommunication.get(this.userData.id)?.PerformAction('DESELECT_OBJECT', { id: this.userData.id });
+        DIVECommunication.get(this.userData.id)?.PerformAction(
+            'DESELECT_OBJECT',
+            { id: this.userData.id },
+        );
     }
 }

package/src/light/SceneLight.ts

@@ -1,5 +1,5 @@
-import { PRODUCT_LAYER_MASK } from "../constant/VisibilityLayerMask.ts";
-import { Color, DirectionalLight, HemisphereLight, Object3D } from "three";
+import { PRODUCT_LAYER_MASK } from '../constant/VisibilityLayerMask.ts';
+import { Color, DirectionalLight, HemisphereLight, Object3D } from 'three';
 
 /**
  * A complex scene light.
@@ -37,10 +37,10 @@ export default class DIVESceneLight extends Object3D {
 
         const d = 5;
 
-        this._dirLight.shadow.camera.left = - d;
+        this._dirLight.shadow.camera.left = -d;
         this._dirLight.shadow.camera.right = d;
         this._dirLight.shadow.camera.top = d;
-        this._dirLight.shadow.camera.bottom = - d;
+        this._dirLight.shadow.camera.bottom = -d;
 
         this._dirLight.shadow.camera.far = 3500;
         this.add(this._dirLight);
@@ -60,4 +60,4 @@ export default class DIVESceneLight extends Object3D {
         this._hemiLight.visible = enabled;
         this._dirLight.visible = enabled;
     }
-}
+}

package/src/light/__test__/AmbientLight.test.ts

@@ -22,10 +22,9 @@ jest.mock('three', () => {
             };
             return this;
         }),
-    }
+    };
 });
 
-
 describe('dive/light/DIVEAmbientLight', () => {
     it('should instantiate', () => {
         const testLight = new DIVEAmbientLight();
@@ -41,7 +40,9 @@ describe('dive/light/DIVEAmbientLight', () => {
     it('should set color', () => {
         const testLight = new DIVEAmbientLight();
         testLight.SetColor({ test: true } as unknown as Color);
-        expect((testLight.children[0] as AmbientLight).color).toEqual({ test: true });
+        expect((testLight.children[0] as AmbientLight).color).toEqual({
+            test: true,
+        });
     });
 
     it('should set enabled', () => {
@@ -49,4 +50,4 @@ describe('dive/light/DIVEAmbientLight', () => {
         testLight.SetEnabled(false);
         expect(testLight.children[0].visible).toBe(false);
     });
-});
+});