@shopware-ag/dive 1.16.0 → 1.16.2

package/src/com/types/COMModel.ts

@@ -1,6 +1,6 @@
-import { type Vector3Like } from "three";
-import { type COMMaterial } from "./COMMaterial";
-import { type COMBaseEntity } from "./COMBaseEntity";
+import { type Vector3Like } from 'three';
+import { type COMMaterial } from './COMMaterial';
+import { type COMBaseEntity } from './COMBaseEntity';
 
 export type COMModel = COMBaseEntity & {
     uri: string;
@@ -9,4 +9,4 @@ export type COMModel = COMBaseEntity & {
     scale: Vector3Like;
     loaded: boolean;
     material?: Partial<COMMaterial>;
-};
+};

package/src/com/types/COMPov.ts

@@ -1,8 +1,8 @@
-import { type Vector3Like } from "three";
-import { type COMBaseEntity } from "./COMBaseEntity";
+import { type Vector3Like } from 'three';
+import { type COMBaseEntity } from './COMBaseEntity';
 
 export type COMPov = COMBaseEntity & {
     position: Vector3Like;
     target: Vector3Like;
     locked?: boolean;
-};
+};

package/src/com/types/COMPrimitive.ts

@@ -1,7 +1,7 @@
-import { type Vector3Like } from "three";
-import { type COMBaseEntity } from "./COMBaseEntity";
-import { type COMGeometry } from "./COMGeometry";
-import { type COMMaterial } from "./COMMaterial";
+import { type Vector3Like } from 'three';
+import { type COMBaseEntity } from './COMBaseEntity';
+import { type COMGeometry } from './COMGeometry';
+import { type COMMaterial } from './COMMaterial';
 
 export type COMPrimitive = COMBaseEntity & {
     position: Vector3Like;
@@ -9,4 +9,4 @@ export type COMPrimitive = COMBaseEntity & {
     scale: Vector3Like;
     geometry: COMGeometry;
     material?: Partial<COMMaterial>;
-};
+};

package/src/com/types/index.ts

@@ -1,12 +1,12 @@
-import { type COMEntity } from "./COMEntity";
-import { type COMPrimitive } from "./COMPrimitive";
-import { type COMModel } from "./COMModel";
-import { type COMLight } from "./COMLight";
-import { type COMPov } from "./COMPov";
-import { type COMGeometry } from "./COMGeometry";
-import { type COMMaterial } from "./COMMaterial";
-import { type COMGroup } from "./COMGroup";
-import { type COMEntityType } from "./COMEntityType";
+import { type COMEntity } from './COMEntity';
+import { type COMPrimitive } from './COMPrimitive';
+import { type COMModel } from './COMModel';
+import { type COMLight } from './COMLight';
+import { type COMPov } from './COMPov';
+import { type COMGeometry } from './COMGeometry';
+import { type COMMaterial } from './COMMaterial';
+import { type COMGroup } from './COMGroup';
+import { type COMEntityType } from './COMEntityType';
 
 export type {
     COMEntity,
@@ -18,4 +18,4 @@ export type {
     COMMaterial,
     COMGroup,
     COMEntityType,
-}
+};

package/src/constant/AxisHelperColors.ts

@@ -4,4 +4,4 @@ export const AxesColorBlueLetter = '#0081d4';
 
 export const AxesColorRed = AxesColorRedLetter;
 export const AxesColorGreen = AxesColorGreenLetter;
-export const AxesColorBlue = AxesColorBlueLetter;
+export const AxesColorBlue = AxesColorBlueLetter;

package/src/constant/GridColors.ts

@@ -1,2 +1,2 @@
 export const GRID_CENTER_LINE_COLOR = '#888888';
-export const GRID_SIDE_LINE_COLOR = '#dddddd';
+export const GRID_SIDE_LINE_COLOR = '#dddddd';

package/src/controls/OrbitControls.ts

@@ -1,19 +1,19 @@
-import { OrbitControls } from "three/examples/jsm/controls/OrbitControls";
-import DIVEPerspectiveCamera from "../camera/PerspectiveCamera.ts";
-import { DIVERenderer } from "../renderer/Renderer.ts";
-import { type Box3, MathUtils, Vector3, Vector3Like } from "three";
-import { Easing } from "@tweenjs/tween.js";
-import { type DIVEAnimationSystem } from "../animation/AnimationSystem.ts";
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';
+import DIVEPerspectiveCamera from '../camera/PerspectiveCamera.ts';
+import { DIVERenderer } from '../renderer/Renderer.ts';
+import { type Box3, MathUtils, Vector3, Vector3Like } from 'three';
+import { Easing } from '@tweenjs/tween.js';
+import { type DIVEAnimationSystem } from '../animation/AnimationSystem.ts';
 
 export type DIVEOrbitControlsSettings = {
     enableDamping: boolean;
     dampingFactor: number;
-}
+};
 
 export const DIVEOrbitControlsDefaultSettings: DIVEOrbitControlsSettings = {
     enableDamping: true,
     dampingFactor: 0.04,
-}
+};
 
 /**
  * Orbit Controls. Basic functionality to orbit around a given target point in the scene.
@@ -26,20 +26,25 @@ export default class DIVEOrbitControls extends OrbitControls {
 
     private _animationSystem: DIVEAnimationSystem;
 
-    private last: { pos: Vector3Like, target: Vector3Like } | null = null;
+    private last: { pos: Vector3Like; target: Vector3Like } | null = null;
 
     private animating: boolean = false;
     private locked: boolean = false;
 
-    private stopMoveTo: () => void = () => { };
-    private stopRevertLast: () => void = () => { };
+    private stopMoveTo: () => void = () => {};
+    private stopRevertLast: () => void = () => {};
 
     public object: DIVEPerspectiveCamera;
     public domElement: HTMLCanvasElement;
 
-    private _removePreRenderCallback: () => void = () => { };
+    private _removePreRenderCallback: () => void = () => {};
 
-    constructor(camera: DIVEPerspectiveCamera, renderer: DIVERenderer, animationSystem: DIVEAnimationSystem, settings: Partial<DIVEOrbitControlsSettings> = DIVEOrbitControlsDefaultSettings) {
+    constructor(
+        camera: DIVEPerspectiveCamera,
+        renderer: DIVERenderer,
+        animationSystem: DIVEAnimationSystem,
+        settings: Partial<DIVEOrbitControlsSettings> = DIVEOrbitControlsDefaultSettings,
+    ) {
         super(camera, renderer.domElement);
 
         this._animationSystem = animationSystem;
@@ -54,10 +59,14 @@ export default class DIVEOrbitControls extends OrbitControls {
 
         this._removePreRenderCallback = () => {
             renderer.RemovePreRenderCallback(id);
-        }
+        };
 
-        this.enableDamping = settings.enableDamping || DIVEOrbitControlsDefaultSettings.enableDamping;
-        this.dampingFactor = settings.dampingFactor || DIVEOrbitControlsDefaultSettings.dampingFactor;
+        this.enableDamping =
+            settings.enableDamping ||
+            DIVEOrbitControlsDefaultSettings.enableDamping;
+        this.dampingFactor =
+            settings.dampingFactor ||
+            DIVEOrbitControlsDefaultSettings.dampingFactor;
 
         // initialize camera transformation
         this.object.position.set(0, 2, 2);
@@ -70,7 +79,10 @@ export default class DIVEOrbitControls extends OrbitControls {
         this.dispose();
     }
 
-    public ComputeEncompassingView(bb: Box3): { position: Vector3Like, target: Vector3Like } {
+    public ComputeEncompassingView(bb: Box3): {
+        position: Vector3Like;
+        target: Vector3Like;
+    } {
         const center = bb.getCenter(new Vector3());
         const size = bb.getSize(new Vector3());
         const distance = Math.max(size.x, size.y, size.z) * 1.25;
@@ -85,7 +97,11 @@ export default class DIVEOrbitControls extends OrbitControls {
     public ZoomIn(by?: number): void {
         const zoomBy = by || DIVEOrbitControls.DEFAULT_ZOOM_FACTOR;
         const { minDistance, maxDistance } = this;
-        this.minDistance = this.maxDistance = MathUtils.clamp(this.getDistance() - zoomBy, minDistance + zoomBy, maxDistance - zoomBy);
+        this.minDistance = this.maxDistance = MathUtils.clamp(
+            this.getDistance() - zoomBy,
+            minDistance + zoomBy,
+            maxDistance - zoomBy,
+        );
         this.update();
         this.minDistance = minDistance;
         this.maxDistance = maxDistance;
@@ -94,13 +110,22 @@ export default class DIVEOrbitControls extends OrbitControls {
     public ZoomOut(by?: number): void {
         const zoomBy = by || DIVEOrbitControls.DEFAULT_ZOOM_FACTOR;
         const { minDistance, maxDistance } = this;
-        this.minDistance = this.maxDistance = MathUtils.clamp(this.getDistance() + zoomBy, minDistance + zoomBy, maxDistance - zoomBy);
+        this.minDistance = this.maxDistance = MathUtils.clamp(
+            this.getDistance() + zoomBy,
+            minDistance + zoomBy,
+            maxDistance - zoomBy,
+        );
         this.update();
         this.minDistance = minDistance;
         this.maxDistance = maxDistance;
     }
 
-    public MoveTo(pos: Vector3Like | undefined, target: Vector3Like | undefined, duration: number, lock: boolean): void {
+    public MoveTo(
+        pos: Vector3Like | undefined,
+        target: Vector3Like | undefined,
+        duration: number,
+        lock: boolean,
+    ): void {
         if (this.animating) return;
 
         const toPosition = pos || this.object.position.clone();
@@ -108,18 +133,24 @@ export default class DIVEOrbitControls extends OrbitControls {
 
         this.stopRevertLast();
 
-        if (!this.locked) this.last = { pos: this.object.position.clone(), target: this.target.clone() };
+        if (!this.locked)
+            this.last = {
+                pos: this.object.position.clone(),
+                target: this.target.clone(),
+            };
 
         this.animating = duration > 0;
         this.locked = lock;
         this.enabled = false;
 
-        const tweenPos = this._animationSystem.Animate(this.object.position)
+        const tweenPos = this._animationSystem
+            .Animate(this.object.position)
             .to(toPosition, duration)
             .easing(Easing.Quadratic.Out)
             .start();
 
-        const tweenQuat = this._animationSystem.Animate(this.target)
+        const tweenQuat = this._animationSystem
+            .Animate(this.target)
             .to(toTarget, duration)
             .easing(Easing.Quadratic.Out)
             .onUpdate(() => {
@@ -134,7 +165,7 @@ export default class DIVEOrbitControls extends OrbitControls {
         this.stopMoveTo = () => {
             tweenPos.stop();
             tweenQuat.stop();
-        }
+        };
     }
 
     public RevertLast(duration: number): void {
@@ -147,12 +178,14 @@ export default class DIVEOrbitControls extends OrbitControls {
 
         const { pos, target } = this.last!;
 
-        const tweenPos = this._animationSystem.Animate(this.object.position)
+        const tweenPos = this._animationSystem
+            .Animate(this.object.position)
             .to(pos, duration)
             .easing(Easing.Quadratic.Out)
             .start();
 
-        const tweenQuat = this._animationSystem.Animate(this.target)
+        const tweenQuat = this._animationSystem
+            .Animate(this.target)
             .to(target, duration)
             .easing(Easing.Quadratic.Out)
             .onUpdate(() => {
@@ -168,11 +201,11 @@ export default class DIVEOrbitControls extends OrbitControls {
         this.stopRevertLast = () => {
             tweenPos.stop();
             tweenQuat.stop();
-        }
+        };
     }
 
     private preRenderCallback = (): void => {
         if (this.locked) return;
         this.update();
-    }
-}
+    };
+}

package/src/controls/__test__/OrbitControls.test.ts

@@ -7,9 +7,9 @@ import { Tween } from '@tweenjs/tween.js';
 
 jest.mock('@tweenjs/tween.js', () => {
     return {
-        Tween: jest.fn(() => { }),
+        Tween: jest.fn(() => {}),
         update: jest.fn(),
-    }
+    };
 });
 
 jest.mock('three/examples/jsm/controls/OrbitControls', () => {
@@ -52,7 +52,7 @@ jest.mock('three/examples/jsm/controls/OrbitControls', () => {
             };
             return this;
         }),
-    }
+    };
 });
 
 jest.mock('../../renderer/Renderer', () => {
@@ -80,7 +80,7 @@ jest.mock('../../animation/AnimationSystem', () => {
 
             return this;
         }),
-    }
+    };
 });
 
 jest.mock('@tweenjs/tween.js', () => {
@@ -94,16 +94,30 @@ jest.mock('@tweenjs/tween.js', () => {
         },
         Tween: jest.fn(() => {
             const instance: object = {
-                easing: () => { return instance; },
-                to: () => { return instance; },
-                start: () => { return instance; },
-                stop: () => { return instance; },
-                onComplete: (callback: () => typeof instance) => { callback(); return instance; },
-                onUpdate: (callback: () => typeof instance) => { callback(); return instance; },
-            }
+                easing: () => {
+                    return instance;
+                },
+                to: () => {
+                    return instance;
+                },
+                start: () => {
+                    return instance;
+                },
+                stop: () => {
+                    return instance;
+                },
+                onComplete: (callback: () => typeof instance) => {
+                    callback();
+                    return instance;
+                },
+                onUpdate: (callback: () => typeof instance) => {
+                    callback();
+                    return instance;
+                },
+            };
             return instance;
         }),
-    }
+    };
 });
 
 const moveToPos = { x: 10, y: 0, z: 0 };
@@ -150,89 +164,165 @@ describe('dive/controls/DIVEOrbitControls', () => {
     });
 
     it('should instantiate', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem, {});
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+            {},
+        );
         expect(controller).toBeDefined();
     });
 
     it('should instantiate with settings', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem, {
-            enableDamping: false,
-            dampingFactor: 0.5,
-        });
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+            {
+                enableDamping: false,
+                dampingFactor: 0.5,
+            },
+        );
         expect(controller).toBeDefined();
     });
 
     it('should dispose', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
         expect(() => controller.Dispose()).not.toThrow();
     });
 
     it('should compute encompassing view', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
-        expect(() => controller.ComputeEncompassingView(new Box3())).not.toThrow();
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
+        expect(() =>
+            controller.ComputeEncompassingView(new Box3()),
+        ).not.toThrow();
     });
 
     it('should zoom in with default value', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
         expect(() => controller.ZoomIn()).not.toThrow();
     });
 
     it('should zoom in with custom value', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
         expect(() => controller.ZoomIn(10)).not.toThrow();
     });
 
     it('should zoom out with default value', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
         expect(() => controller.ZoomOut()).not.toThrow();
     });
 
     it('should zoom out with custom value', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
         expect(() => controller.ZoomOut(10)).not.toThrow();
     });
 
     it('should move to', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
-        expect(() => controller.MoveTo(moveToPos, moveToQuat, moveToDuration, false)).not.toThrow();
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
+        expect(() =>
+            controller.MoveTo(moveToPos, moveToQuat, moveToDuration, false),
+        ).not.toThrow();
     });
 
     it('should revert move to', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
         controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true);
         expect(() => controller.RevertLast(moveToDuration)).not.toThrow();
     });
 
     it('should revert move to without values', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
-        expect(() => controller.MoveTo(undefined, undefined, moveToDuration, true)).not.toThrow();
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
+        expect(() =>
+            controller.MoveTo(undefined, undefined, moveToDuration, true),
+        ).not.toThrow();
     });
 
     it('should revert move to with lock', async () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
         controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true);
         expect(() => controller.RevertLast(moveToDuration)).not.toThrow();
     });
 
     it('should move after revert with lock', async () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
         controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true);
         controller.RevertLast(moveToDuration);
-        expect(() => controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true)).not.toThrow();
+        expect(() =>
+            controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true),
+        ).not.toThrow();
     });
 
     it('should catch multiple move tos', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
         controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true);
         controller.RevertLast(moveToDuration);
-        expect(() => controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true)).not.toThrow();
+        expect(() =>
+            controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true),
+        ).not.toThrow();
         controller['animating'] = true;
-        expect(() => controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true)).not.toThrow();
-        expect(() => controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true)).not.toThrow();
+        expect(() =>
+            controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true),
+        ).not.toThrow();
+        expect(() =>
+            controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true),
+        ).not.toThrow();
     });
 
     it('should catch multiple reverts', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
         controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true);
         expect(() => controller.RevertLast(moveToDuration)).not.toThrow();
         expect(() => controller.RevertLast(moveToDuration)).not.toThrow();
@@ -240,10 +330,14 @@ describe('dive/controls/DIVEOrbitControls', () => {
     });
 
     it('should execute preRenderCallback', () => {
-        const controller = new DIVEOrbitControls(mockCamera, mockRenderer, mockAnimSystem);
+        const controller = new DIVEOrbitControls(
+            mockCamera,
+            mockRenderer,
+            mockAnimSystem,
+        );
         controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true);
         expect(() => controller['preRenderCallback']()).not.toThrow();
         controller['locked'] = true;
         expect(() => controller['preRenderCallback']()).not.toThrow();
     });
-});
+});