@shopware-ag/dive 1.19.0 → 1.19.1-beta.1

package/src/loadingmanager/__test__/LoadingManager.test.ts

@@ -1,27 +0,0 @@
-import { DIVELoadingManager } from '../LoadingManager';
-
-describe('dive/loadingmanager/DIVELoadingManager', () => {
-    it('should instantiate', () => {
-        const testLight = new DIVELoadingManager();
-        expect(testLight).toBeDefined();
-    });
-
-    it('should return GLTF promise', () => {
-        const testLight = new DIVELoadingManager();
-        const promise = testLight.LoadGLTF('test.gltf');
-        expect(promise).toBeDefined();
-    });
-
-    it('should return progress', () => {
-        const testLight = new DIVELoadingManager();
-        testLight.LoadGLTF('test.gltf');
-        const progress = testLight.PollProgress();
-        expect(progress).toBe(0);
-    });
-
-    it('should return done progress without load', () => {
-        const testLight = new DIVELoadingManager();
-        const progress = testLight.PollProgress();
-        expect(progress).toBe(1);
-    });
-});

package/src/math/__test__/DIVEMath.test.ts

@@ -1,12 +0,0 @@
-import { DIVEMath } from '../index';
-
-describe('dive/math', () => {
-    it('should be defined', () => {
-        expect(DIVEMath).toBeDefined();
-        expect(DIVEMath.ceilExp).toBeDefined();
-        expect(DIVEMath.floorExp).toBeDefined();
-        expect(DIVEMath.roundExp).toBeDefined();
-        expect(DIVEMath.toFixedExp).toBeDefined();
-        expect(DIVEMath.truncateExp).toBeDefined();
-    });
-});

package/src/math/ceil/__test__/ceilExp.test.ts

@@ -1,12 +0,0 @@
-import ceilExp from '../ceilExp';
-
-describe('dive/math/ceil/ceilExp', () => {
-    it('should ceilExp', () => {
-        expect(ceilExp(-0.5)).toBe(0);
-        expect(ceilExp(0.5)).toBe(1);
-        expect(ceilExp(0.55)).toBe(1);
-        expect(ceilExp(0.49)).toBe(1);
-        expect(ceilExp(0.49, 2)).toBe(0.49);
-        expect(ceilExp(-1.49, 2)).toBe(-1.49);
-    });
-});

package/src/math/ceil/ceilExp.ts

@@ -1,6 +0,0 @@
-import shift from '../helper/shift.ts';
-
-export default function ceilExp(number: number, decimals: number = 0): number {
-    const n = shift(number, +decimals);
-    return shift(Math.ceil(n), -decimals);
-}

package/src/math/degToRad/__test__/degToRad.test.ts

@@ -1,172 +0,0 @@
-import degToRad from '../degToRad';
-import { MathUtils } from 'three';
-
-// 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

@@ -1,5 +0,0 @@
-import { MathUtils } from 'three';
-
-export default function degToRad(degrees: number): number {
-    return MathUtils.degToRad(degrees);
-}

package/src/math/floor/__test__/floorExp.test.ts

@@ -1,14 +0,0 @@
-import floorExp from '../floorExp';
-
-describe('dive/math/floor/floorExp', () => {
-    it('should floorExp', () => {
-        expect(floorExp(-0.5)).toBe(-1);
-        expect(floorExp(0.5)).toBe(0);
-        expect(floorExp(0.55)).toBe(0);
-        expect(floorExp(0.49)).toBe(0);
-        expect(floorExp(1.49)).toBe(1);
-        expect(floorExp(0.49, 2)).toBe(0.49);
-        expect(floorExp(1.49, 2)).toBe(1.49);
-        expect(floorExp(-1.49, 2)).toBe(-1.49);
-    });
-});

package/src/math/floor/floorExp.ts

@@ -1,6 +0,0 @@
-import shift from '../helper/shift.ts';
-
-export default function floorExp(number: number, decimals: number = 0): number {
-    const n = shift(number, +decimals);
-    return shift(Math.floor(n), -decimals);
-}

package/src/math/helper/__test__/shift.test.ts

@@ -1,12 +0,0 @@
-import shift from '../shift';
-
-describe('dive/math/helper/shift', () => {
-    it('should shift', () => {
-        expect(shift(0.5, 2)).toBe(50);
-        expect(shift(0.55, 2)).toBe(55);
-        expect(shift(0.49, 2)).toBe(49);
-        expect(shift(1.49, 2)).toBe(149);
-        expect(shift(0.49, 2)).toBe(49);
-        expect(shift(1.49, 2)).toBe(149);
-    });
-});

package/src/math/helper/shift.ts

@@ -1,4 +0,0 @@
-export default function shift(value: number, exponent: number): number {
-    const subvalues = (value + 'e').split('e');
-    return +(subvalues[0] + 'e' + (+subvalues[1] + (exponent || 0)));
-}

package/src/math/index.ts

@@ -1,28 +0,0 @@
-import ceilExp from './ceil/ceilExp.ts';
-import floorExp from './floor/floorExp.ts';
-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;
-    floorExp: typeof floorExp;
-    roundExp: typeof roundExp;
-    toFixedExp: typeof toFixedExp;
-    truncateExp: typeof truncateExp;
-    signedAngleTo: typeof signedAngleTo;
-    radToDeg: typeof radToDeg;
-    degToRad: typeof degToRad;
-} = {
-    ceilExp,
-    floorExp,
-    roundExp,
-    toFixedExp,
-    truncateExp,
-    signedAngleTo,
-    radToDeg,
-    degToRad,
-};

package/src/math/radToDeg/__test__/radToDeg.test.ts

@@ -1,155 +0,0 @@
-import radToDeg from '../radToDeg';
-import { MathUtils } from 'three';
-
-// 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

@@ -1,5 +0,0 @@
-import { MathUtils } from 'three';
-
-export default function radToDeg(radians: number): number {
-    return (MathUtils.radToDeg(radians) + 360) % 360;
-}

package/src/math/round/__test__/roundExp.test.ts

@@ -1,14 +0,0 @@
-import roundExp from '../roundExp';
-
-describe('dive/math/round/roundExp', () => {
-    it('should roundExp', () => {
-        expect(roundExp(-0.5)).toBe(-1);
-        expect(roundExp(0.5)).toBe(1);
-        expect(roundExp(0.55)).toBe(1);
-        expect(roundExp(0.49)).toBe(0);
-        expect(roundExp(1.49)).toBe(1);
-        expect(roundExp(0.49, 2)).toBe(0.49);
-        expect(roundExp(1.49, 2)).toBe(1.49);
-        expect(roundExp(-1.49, 2)).toBe(-1.49);
-    });
-});

package/src/math/round/roundExp.ts

@@ -1,10 +0,0 @@
-import shift from '../helper/shift.ts';
-
-export default function roundExponential(
-    number: number,
-    decimals: number = 0,
-): number {
-    if (number < 0) return -roundExponential(-number, decimals);
-    const n = shift(number, +decimals);
-    return shift(Math.round(n), -decimals);
-}

package/src/math/signedAngleTo/__test__/signedAngleTo.test.ts

@@ -1,20 +0,0 @@
-import { Vector3 } from 'three';
-import signedAngleTo from '../signedAngleTo';
-
-describe('dive/math/signedAngleTo', () => {
-    it('should signedAngleTo', () => {
-        const planeNormal = new Vector3(0, 0, 1);
-        const a = new Vector3(1, 0, 0);
-        expect(signedAngleTo(a, new Vector3(1, 0, 0), planeNormal)).toBe(0);
-        expect(signedAngleTo(a, new Vector3(0, 1, 0), planeNormal)).toBe(
-            Math.PI / 2,
-        );
-        expect(signedAngleTo(a, new Vector3(-1, 0, 0), planeNormal)).toBe(
-            Math.PI,
-        );
-        expect(signedAngleTo(a, new Vector3(0, -1, 0), planeNormal)).toBe(
-            -Math.PI / 2,
-        );
-        expect(signedAngleTo(a, planeNormal, planeNormal)).toBe(0);
-    });
-});

package/src/math/signedAngleTo/signedAngleTo.ts

@@ -1,20 +0,0 @@
-import { Vector3 } from 'three';
-
-/**
- * Calculate the signed angle between two vectors. Only works when the vectors are on the same plane.
- * @param vecB Start Vector
- * @param vecA Target Vector
- * @param planeNormal The vector's plane normal
- * @returns Signed angle in radians
- */
-
-export default function signedAngleTo(
-    vecA: Vector3,
-    vecB: Vector3,
-    planeNormal: Vector3,
-): number {
-    return Math.atan2(
-        vecA.clone().cross(vecB).dot(planeNormal),
-        vecB.clone().dot(vecA),
-    );
-}

package/src/math/toFixed/__test__/toFixedExp.test.ts

@@ -1,14 +0,0 @@
-import toFixedExp from '../toFixedExp';
-
-describe('dive/math/toFixed/toFixedExp', () => {
-    it('should toFixedExp', () => {
-        expect(toFixedExp(-0.5)).toBe('0');
-        expect(toFixedExp(0.5)).toBe('1');
-        expect(toFixedExp(0.55)).toBe('1');
-        expect(toFixedExp(0.49)).toBe('0');
-        expect(toFixedExp(1.49)).toBe('1');
-        expect(toFixedExp(0.49, 2)).toBe('0.49');
-        expect(toFixedExp(1.49, 2)).toBe('1.49');
-        expect(toFixedExp(-1.49, 2)).toBe('-1.49');
-    });
-});

package/src/math/toFixed/toFixedExp.ts

@@ -1,9 +0,0 @@
-import shift from '../helper/shift.ts';
-
-export default function toFixedExp(
-    number: number,
-    decimals: number = 0,
-): string {
-    const n = shift(number, +decimals);
-    return shift(Math.round(n), -decimals).toFixed(decimals);
-}

package/src/math/truncate/__test__/truncateExp.test.ts

@@ -1,14 +0,0 @@
-import truncateExp from '../truncateExp';
-
-describe('dive/math/truncate/truncateExp', () => {
-    it('should truncateExp', () => {
-        expect(truncateExp(-0.5)).toBe(0);
-        expect(truncateExp(0.5)).toBe(0);
-        expect(truncateExp(0.55)).toBe(0);
-        expect(truncateExp(0.49)).toBe(0);
-        expect(truncateExp(1.49)).toBe(1);
-        expect(truncateExp(0.49, 2)).toBe(0.49);
-        expect(truncateExp(1.49, 2)).toBe(1.49);
-        expect(truncateExp(-1.49, 2)).toBe(-1.49);
-    });
-});

package/src/math/truncate/truncateExp.ts

@@ -1,9 +0,0 @@
-import shift from '../helper/shift.ts';
-
-export default function truncateExp(
-    number: number,
-    decimals: number = 0,
-): number {
-    const n = shift(number, +decimals);
-    return shift(Math.trunc(n), -decimals);
-}

package/src/mediacreator/MediaCreator.ts

@@ -1,75 +0,0 @@
-import DIVEPerspectiveCamera from '../camera/PerspectiveCamera.ts';
-import { type DIVEScene } from '../scene/Scene.ts';
-import { type DIVERenderer } from '../renderer/Renderer.ts';
-import type DIVEOrbitControls from '../controls/OrbitControls.ts';
-import { type Vector3Like } from 'three';
-
-/**
- * Creates renderings of the current scene
- *
- * @module
- */
-
-export class DIVEMediaCreator {
-    private renderer: DIVERenderer;
-    private scene: DIVEScene;
-    private controller: DIVEOrbitControls;
-
-    constructor(
-        renderer: DIVERenderer,
-        scene: DIVEScene,
-        controller: DIVEOrbitControls,
-    ) {
-        this.renderer = renderer;
-        this.scene = scene;
-        this.controller = controller;
-    }
-
-    public GenerateMedia(
-        position: Vector3Like,
-        target: Vector3Like,
-        width: number,
-        height: number,
-    ): string {
-        const resetPosition = this.controller.object.position.clone();
-        const resetRotation = this.controller.object.quaternion.clone();
-
-        this.renderer.OnResize(width, height);
-        this.controller.object.OnResize(width, height);
-
-        this.controller.object.position.copy(position);
-        this.controller.target.copy(target);
-        this.controller.update();
-
-        const dataUri = this.DrawCanvas().toDataURL();
-
-        this.controller.object.position.copy(resetPosition);
-        this.controller.object.quaternion.copy(resetRotation);
-
-        return dataUri;
-    }
-
-    public DrawCanvas(canvasElement?: HTMLCanvasElement): HTMLCanvasElement {
-        // save current canvas
-        const restore = this.renderer.domElement;
-        if (canvasElement) {
-            this.renderer.domElement = canvasElement;
-        }
-
-        // draw canvas
-        this.controller.object.layers.mask =
-            DIVEPerspectiveCamera.LIVE_VIEW_LAYER_MASK;
-        this.renderer.render(this.scene, this.controller.object);
-        this.controller.object.layers.mask =
-            DIVEPerspectiveCamera.EDITOR_VIEW_LAYER_MASK;
-
-        const returnCanvas = this.renderer.domElement;
-
-        // restore canvas
-        if (canvasElement) {
-            this.renderer.domElement = restore;
-        }
-
-        return returnCanvas;
-    }
-}