@shopware-ag/dive 1.16.0 → 1.16.2

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

@@ -33,16 +33,15 @@ jest.mock('../select/SelectTool.ts', () => {
             this.SetGizmoMode = jest.fn();
             this.SetGizmoVisibility = jest.fn();
             return this;
-        })
-    }
+        }),
+    };
 });
 
 const mockController = {
     domElement: mock_Canvas,
-    object: {}
+    object: {},
 } as unknown as DIVEOrbitControls;
 
-
 describe('dive/toolbox/DIVEToolBox', () => {
     afterEach(() => {
         jest.clearAllMocks();
@@ -61,7 +60,9 @@ describe('dive/toolbox/DIVEToolBox', () => {
 
     it('should throw with incorrect tool', () => {
         const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() => toolBox.UseTool('not a real tool' as unknown as ToolType)).toThrow();
+        expect(() =>
+            toolBox.UseTool('not a real tool' as unknown as ToolType),
+        ).toThrow();
     });
 
     it('should use no tool', () => {
@@ -77,30 +78,46 @@ describe('dive/toolbox/DIVEToolBox', () => {
 
     it('should execute pointer down event on tool', () => {
         const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() => toolBox.onPointerDown({ type: 'pointerdown' } as PointerEvent)).not.toThrow();
+        expect(() =>
+            toolBox.onPointerDown({ type: 'pointerdown' } as PointerEvent),
+        ).not.toThrow();
         expect(() => toolBox.UseTool('select')).not.toThrow();
-        expect(() => toolBox.onPointerDown({ type: 'pointerdown' } as PointerEvent)).not.toThrow();
+        expect(() =>
+            toolBox.onPointerDown({ type: 'pointerdown' } as PointerEvent),
+        ).not.toThrow();
     });
 
     it('should execute pointer move event on tool', () => {
         const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() => toolBox.onPointerMove({ type: 'pointermove' } as PointerEvent)).not.toThrow();
+        expect(() =>
+            toolBox.onPointerMove({ type: 'pointermove' } as PointerEvent),
+        ).not.toThrow();
         expect(() => toolBox.UseTool('select')).not.toThrow();
-        expect(() => toolBox.onPointerMove({ type: 'pointermove' } as PointerEvent)).not.toThrow();
+        expect(() =>
+            toolBox.onPointerMove({ type: 'pointermove' } as PointerEvent),
+        ).not.toThrow();
     });
 
     it('should execute pointer up event on tool', () => {
         const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() => toolBox.onPointerUp({ type: 'pointerup' } as PointerEvent)).not.toThrow();
+        expect(() =>
+            toolBox.onPointerUp({ type: 'pointerup' } as PointerEvent),
+        ).not.toThrow();
         expect(() => toolBox.UseTool('select')).not.toThrow();
-        expect(() => toolBox.onPointerUp({ type: 'pointerup' } as PointerEvent)).not.toThrow();
+        expect(() =>
+            toolBox.onPointerUp({ type: 'pointerup' } as PointerEvent),
+        ).not.toThrow();
     });
 
     it('should execute wheel event on tool', () => {
         const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() => toolBox.onWheel({ type: 'wheel' } as WheelEvent)).not.toThrow();
+        expect(() =>
+            toolBox.onWheel({ type: 'wheel' } as WheelEvent),
+        ).not.toThrow();
         expect(() => toolBox.UseTool('select')).not.toThrow();
-        expect(() => toolBox.onWheel({ type: 'wheel' } as WheelEvent)).not.toThrow();
+        expect(() =>
+            toolBox.onWheel({ type: 'wheel' } as WheelEvent),
+        ).not.toThrow();
     });
 
     it('should get active tool', () => {
@@ -117,4 +134,4 @@ describe('dive/toolbox/DIVEToolBox', () => {
         const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
         expect(() => toolBox.SetGizmoVisibility(true)).not.toThrow();
     });
-});
+});

package/src/toolbox/select/SelectTool.ts

@@ -1,18 +1,18 @@
-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 } from "../../interface/Selectable.ts";
-import { type DIVEMovable } from "../../interface/Movable.ts";
-import { type DIVEBaseTool } from "../BaseTool.ts";
+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 } 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 => {
     return (tool as DIVESelectTool).isSelectTool !== undefined;
-}
+};
 
 export interface DIVEObjectEventMap {
-    select: object
+    select: object;
 }
 
 /**
@@ -28,11 +28,10 @@ export class DIVESelectTool extends DIVETransformTool {
 
     constructor(scene: DIVEScene, controller: DIVEOrbitControls) {
         super(scene, controller);
-        this.name = "SelectTool";
+        this.name = 'SelectTool';
     }
 
-    public Activate(): void { }
-
+    public Activate(): void {}
 
     public Select(selectable: DIVESelectable): void {
         if (selectable.onSelect) selectable.onSelect();
@@ -48,7 +47,9 @@ export class DIVESelectTool extends DIVETransformTool {
 
     public AttachGizmo(selectable: DIVESelectable): void {
         if ('isMovable' in selectable) {
-            const movable = selectable as (Object3D & DIVESelectable & DIVEMovable);
+            const movable = selectable as Object3D &
+                DIVESelectable &
+                DIVEMovable;
             this._gizmo.attach(movable);
             this.SetGizmoVisibility(movable.visible);
         }
@@ -61,8 +62,13 @@ export class DIVESelectTool extends DIVETransformTool {
     public onClick(e: PointerEvent): void {
         super.onClick(e);
 
-        const first = this._raycaster.intersectObjects(this._scene.Root.children, true).filter((intersect) => intersect.object.visible)[0];
-        const selectable = findInterface<DIVESelectable>(first?.object, 'isSelectable');
+        const first = this._raycaster
+            .intersectObjects(this._scene.Root.children, true)
+            .filter((intersect) => intersect.object.visible)[0];
+        const selectable = findInterface<DIVESelectable>(
+            first?.object,
+            'isSelectable',
+        );
 
         // if nothing is hit
         if (!first || !selectable) {
@@ -77,11 +83,10 @@ export class DIVESelectTool extends DIVETransformTool {
             if (this._gizmo.object.uuid === selectable.uuid) return;
 
             // deselect previous object
-            this.Deselect(this._gizmo.object as (Object3D & DIVESelectable));
+            this.Deselect(this._gizmo.object as Object3D & DIVESelectable);
         }
 
-
         // select clicked object
         this.Select(selectable);
     }
-}
+}

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

@@ -1,7 +1,7 @@
 import { DIVESelectTool, isSelectTool } from '../SelectTool';
 import { DIVEScene } from '../../../scene/Scene';
 import DIVEOrbitControls from '../../../controls/OrbitControls';
-import { DIVERenderer, DIVERendererDefaultSettings } from '../../../renderer/Renderer';
+import { DIVERenderer } from '../../../renderer/Renderer';
 import { DIVESelectable } from '../../../interface/Selectable';
 import type DIVEPerspectiveCamera from '../../../camera/PerspectiveCamera';
 import { type Object3D } from 'three';
@@ -11,9 +11,9 @@ import { Tween } from '@tweenjs/tween.js';
 
 jest.mock('@tweenjs/tween.js', () => {
     return {
-        Tween: jest.fn(() => { }),
+        Tween: jest.fn(() => {}),
         update: jest.fn(),
-    }
+    };
 });
 
 jest.mock('../../../renderer/Renderer', () => {
@@ -42,13 +42,12 @@ jest.mock('../../../controls/OrbitControls', () => {
         this.object = {
             layers: {
                 mask: 0,
-            }
+            },
         };
         return this;
     });
 });
 
-
 jest.mock('../../../animation/AnimationSystem', () => {
     return {
         DIVEAnimationSystem: jest.fn(function () {
@@ -61,7 +60,7 @@ jest.mock('../../../animation/AnimationSystem', () => {
 
             return this;
         }),
-    }
+    };
 });
 
 jest.mock('../../../scene/Scene', () => {
@@ -71,9 +70,9 @@ jest.mock('../../../scene/Scene', () => {
             this.children = [];
             this.Root = {
                 children: [],
-            }
+            };
             return this;
-        })
+        }),
     };
 });
 
@@ -104,7 +103,10 @@ const mock_detach = jest.fn();
 jest.mock('three/examples/jsm/Addons.js', () => {
     return {
         TransformControls: jest.fn(function () {
-            this.addEventListener = (type: string, callback: (e: object) => void) => {
+            (this.addEventListener = (
+                type: string,
+                callback: (e: object) => void,
+            ) => {
                 callback({ value: false });
                 this.object = {};
                 callback({ value: false });
@@ -116,12 +118,12 @@ jest.mock('three/examples/jsm/Addons.js', () => {
                     onMove: jest.fn(),
                 };
                 callback({ value: false });
-            },
-                this.attach = mock_attach,
-                this.detach = mock_detach,
-                this.traverse = function (callback: (obj: object) => void) {
+            }),
+                (this.attach = mock_attach),
+                (this.detach = mock_detach),
+                (this.traverse = function (callback: (obj: object) => void) {
                     callback(this);
-                };
+                });
             this.setMode = jest.fn();
             this.getRaycaster = jest.fn().mockReturnValue({
                 layers: {
@@ -143,7 +145,11 @@ const mockRenderer = {
 } as unknown as DIVERenderer;
 const mockScene: DIVEScene = new DIVEScene();
 const mockAnimSystem = new DIVEAnimationSystem(mockRenderer);
-const mockController: DIVEOrbitControls = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+const mockController: DIVEOrbitControls = new DIVEOrbitControls(
+    mockCamera,
+    mockRenderer,
+    mockAnimSystem,
+);
 
 describe('dive/toolbox/select/DIVESelectTool', () => {
     it('should test if it is SelectTool', () => {
@@ -163,94 +169,119 @@ describe('dive/toolbox/select/DIVESelectTool', () => {
 
     it('should execute onClick without hit', () => {
         const selectTool = new DIVESelectTool(mockScene, mockController);
-        selectTool['_gizmo'].object = {} as unknown as Object3D & DIVESelectable;
-        expect(() => selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
+        selectTool['_gizmo'].object = {} as unknown as Object3D &
+            DIVESelectable;
+        expect(() =>
+            selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent),
+        ).not.toThrow();
     });
 
     it('should execute onClick with hit', () => {
-        mock_intersectObjects.mockReturnValueOnce(
-            [{
+        mock_intersectObjects.mockReturnValueOnce([
+            {
                 object: {
                     uuid: 'test',
                     visible: true,
-                    parent: { name: 'this is the test scene root!!!', parent: null }
-                }
-            }]
-        );
+                    parent: {
+                        name: 'this is the test scene root!!!',
+                        parent: null,
+                    },
+                },
+            },
+        ]);
         const selectTool = new DIVESelectTool(mockScene, mockController);
-        expect(() => selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
+        expect(() =>
+            selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent),
+        ).not.toThrow();
     });
 
     it('should execute onClick with same ISelectable hit', () => {
         const mock_onSelect = jest.fn();
 
-        mock_intersectObjects.mockReturnValueOnce([{
-            object: {
-                isSelectable: true,
-                onSelect: mock_onSelect,
-                visible: true,
-                parent: {
-                    name: 'this is the test scene root!!!',
-                    parent: null,
+        mock_intersectObjects.mockReturnValueOnce([
+            {
+                object: {
+                    isSelectable: true,
+                    onSelect: mock_onSelect,
+                    visible: true,
+                    parent: {
+                        name: 'this is the test scene root!!!',
+                        parent: null,
+                    },
+                    uuid: 'test0',
                 },
-                uuid: 'test0',
             },
-        }]);
+        ]);
         const selectTool = new DIVESelectTool(mockScene, mockController);
         selectTool['_gizmo'].object = {
             visible: true,
             isSelectable: true,
             uuid: 'test0',
         } as unknown as Object3D & DIVESelectable;
-        expect(() => selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
+        expect(() =>
+            selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent),
+        ).not.toThrow();
     });
 
     it('should execute onClick with ISelectable hit', () => {
         const mock_onSelect = jest.fn();
 
-        mock_intersectObjects.mockReturnValueOnce([{
-            object: {
-                isSelectable: true,
-                onSelect: mock_onSelect,
-                visible: true,
-                parent: {
-                    name: 'this is the test scene root!!!',
-                    parent: null,
+        mock_intersectObjects.mockReturnValueOnce([
+            {
+                object: {
+                    isSelectable: true,
+                    onSelect: mock_onSelect,
+                    visible: true,
+                    parent: {
+                        name: 'this is the test scene root!!!',
+                        parent: null,
+                    },
+                    uuid: 'test0',
                 },
-                uuid: 'test0',
             },
-        }]);
+        ]);
         const selectTool = new DIVESelectTool(mockScene, mockController);
         selectTool['_gizmo'].object = {
             isSelectable: true,
             uuid: 'test1',
         } as unknown as Object3D & DIVESelectable;
-        expect(() => selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
+        expect(() =>
+            selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent),
+        ).not.toThrow();
     });
 
     it('should execute onClick with IMovable hit', () => {
         const mock_onSelect = jest.fn();
 
-        mock_intersectObjects.mockReturnValueOnce([{
-            object: {
-                isSelectable: true,
-                isMovable: true,
-                onSelect: mock_onSelect,
-                parent: {
-                    name: 'this is the test scene root!!!',
-                    parent: null,
+        mock_intersectObjects.mockReturnValueOnce([
+            {
+                object: {
+                    isSelectable: true,
+                    isMovable: true,
+                    onSelect: mock_onSelect,
+                    parent: {
+                        name: 'this is the test scene root!!!',
+                        parent: null,
+                    },
                 },
             },
-        }]);
+        ]);
         const selectTool = new DIVESelectTool(mockScene, mockController);
-        expect(() => selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
+        expect(() =>
+            selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent),
+        ).not.toThrow();
     });
 
     it('should Select', () => {
         const selectTool = new DIVESelectTool(mockScene, mockController);
         const mock_onSelect = jest.fn();
         expect(() => selectTool.Select({ isSelectable: true })).not.toThrow();
-        expect(() => selectTool.Select({ isMovable: 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 +289,12 @@ 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({ isMovable: 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);
     });
 
@@ -266,4 +302,4 @@ describe('dive/toolbox/select/DIVESelectTool', () => {
         const selectTool = new DIVESelectTool(mockScene, mockController);
         expect(() => selectTool.SetGizmoMode('translate')).not.toThrow();
     });
-});
+});

package/src/toolbox/transform/TransformTool.ts

@@ -1,16 +1,18 @@
-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 DIVEMovable } from "../../interface/Movable.ts";
-import { implementsInterface } from "../../helper/isInterface/implementsInterface.ts";
-
-export const isTransformTool = (tool: DIVEBaseTool): tool is DIVETransformTool => {
+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 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;
-}
+};
 
 export interface DIVEObjectEventMap {
-    select: object
+    select: object;
 }
 
 /**
@@ -28,23 +30,38 @@ export default class DIVETransformTool extends DIVEBaseTool {
 
     constructor(scene: DIVEScene, controller: DIVEOrbitControls) {
         super(scene, controller);
-        this.name = "DIVETransformTool";
+        this.name = 'DIVETransformTool';
 
-        this._gizmo = new TransformControls(this._controller.object, this._controller.domElement);
+        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 (
+                !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 (
+                !implementsInterface<DIVEMovable>(
+                    this._gizmo.object,
+                    'isMovable',
+                )
+            )
+                return;
             if (!this._gizmo.object.onMove) return;
             this._gizmo.object.onMove();
         });
@@ -53,7 +70,13 @@ export default class DIVETransformTool extends DIVEBaseTool {
         this._gizmo.addEventListener('mouseUp', () => {
             controller.enabled = true;
 
-            if (!implementsInterface<DIVEMovable>(this._gizmo.object, 'isMovable')) return;
+            if (
+                !implementsInterface<DIVEMovable>(
+                    this._gizmo.object,
+                    'isMovable',
+                )
+            )
+                return;
             if (!this._gizmo.object.onMoveEnd) return;
             this._gizmo.object.onMoveEnd();
         });
@@ -61,7 +84,7 @@ export default class DIVETransformTool extends DIVEBaseTool {
         scene.add(this._gizmo);
     }
 
-    public Activate(): void { }
+    public Activate(): void {}
 
     public SetGizmoMode(mode: 'translate' | 'rotate' | 'scale'): void {
         this._gizmo.mode = mode;
@@ -87,4 +110,4 @@ export default class DIVETransformTool extends DIVEBaseTool {
     // protected raycast(): Intersection[] {
     //     return super.raycast(this._gizmo.gizmoNode.children);
     // }
-}
+}

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

@@ -9,9 +9,9 @@ import { DIVEAnimationSystem } from '../../../animation/AnimationSystem';
 
 jest.mock('@tweenjs/tween.js', () => {
     return {
-        Tween: jest.fn(() => { }),
+        Tween: jest.fn(() => {}),
         update: jest.fn(),
-    }
+    };
 });
 
 jest.mock('../../../renderer/Renderer', () => {
@@ -40,7 +40,7 @@ jest.mock('../../../controls/OrbitControls', () => {
         this.object = {
             layers: {
                 mask: 0,
-            }
+            },
         };
         return this;
     });
@@ -53,10 +53,10 @@ jest.mock('../../../scene/Scene', () => {
             this.remove = jest.fn();
             this.Root = {
                 children: [],
-            }
+            };
             this.children = [];
             return this;
-        })
+        }),
     };
 });
 
@@ -72,7 +72,7 @@ jest.mock('../../../animation/AnimationSystem', () => {
 
             return this;
         }),
-    }
+    };
 });
 
 const mock_intersectObjects = jest.fn().mockReturnValue([]);
@@ -102,13 +102,16 @@ const mock_detach = jest.fn();
 jest.mock('three/examples/jsm/Addons.js', () => {
     return {
         TransformControls: jest.fn(function () {
-            this.addEventListener = (type: string, callback: (e: object) => void) => {
+            (this.addEventListener = (
+                type: string,
+                callback: (e: object) => void,
+            ) => {
                 this.object = null;
                 callback({ value: false });
                 this.object = {};
                 callback({ value: false });
                 this.object = {
-                    isMovable: true
+                    isMovable: true,
                 };
                 callback({ value: false });
                 this.object = {
@@ -118,12 +121,12 @@ jest.mock('three/examples/jsm/Addons.js', () => {
                     onMoveEnd: jest.fn(),
                 };
                 callback({ value: false });
-            },
-                this.attach = mock_attach,
-                this.detach = mock_detach,
-                this.traverse = function (callback: (obj: object) => void) {
+            }),
+                (this.attach = mock_attach),
+                (this.detach = mock_detach),
+                (this.traverse = function (callback: (obj: object) => void) {
                     callback(this);
-                };
+                });
             this.setMode = jest.fn();
             this.getRaycaster = jest.fn().mockReturnValue({
                 layers: {
@@ -155,7 +158,11 @@ const mockRenderer = {
 } as unknown as DIVERenderer;
 const mockScene: DIVEScene = new DIVEScene();
 const mockAnimSystem = new DIVEAnimationSystem(mockRenderer);
-const mockController: DIVEOrbitControls = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+const mockController: DIVEOrbitControls = new DIVEOrbitControls(
+    mockCamera,
+    mockRenderer,
+    mockAnimSystem,
+);
 
 describe('dive/toolbox/select/DIVETransformTool', () => {
     it('should test if it is SelectTool', () => {
@@ -187,4 +194,4 @@ describe('dive/toolbox/select/DIVETransformTool', () => {
         mockScene.children.includes = jest.fn().mockReturnValue(true);
         expect(() => transformTool.SetGizmoVisibility(false)).not.toThrow();
     });
-});
+});

package/src/types/SceneObjects.ts

@@ -1,14 +1,14 @@
-import { DIVEGroup } from "../group/Group";
-import DIVEAmbientLight from "../light/AmbientLight";
-import DIVEPointLight from "../light/PointLight";
-import DIVESceneLight from "../light/SceneLight";
-import { DIVEModel } from "../model/Model";
-import { DIVEPrimitive } from "../primitive/Primitive";
+import { DIVEGroup } from '../group/Group';
+import DIVEAmbientLight from '../light/AmbientLight';
+import DIVEPointLight from '../light/PointLight';
+import DIVESceneLight from '../light/SceneLight';
+import { DIVEModel } from '../model/Model';
+import { DIVEPrimitive } from '../primitive/Primitive';
 
 export type DIVESceneObject =
-    DIVEModel
+    | DIVEModel
     | DIVEGroup
     | DIVEPrimitive
     | DIVEAmbientLight
     | DIVEPointLight
-    | DIVESceneLight;
+    | DIVESceneLight;