@shopware-ag/dive 1.19.1-beta.0 → 1.19.1-beta.2

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

@@ -1,74 +0,0 @@
-import DIVEPointLight from '../PointLight.ts';
-import { DIVECommunication } from '../../com/Communication.ts';
-import { Color, MeshBasicMaterial, Object3D, PointLight } from 'three';
-
-jest.mock('../../com/Communication.ts', () => {
-    return {
-        DIVECommunication: {
-            get: jest.fn(() => {
-                return {
-                    PerformAction: jest.fn(),
-                };
-            }),
-        },
-    };
-});
-
-describe('dive/light/DIVEPointLight', () => {
-    it('should instantiate', () => {
-        const testLight = new DIVEPointLight();
-        testLight.userData.id = 'something';
-        expect(testLight).toBeDefined();
-        expect(testLight.userData.id).toBe('something');
-        expect(testLight.children).toHaveLength(2);
-    });
-
-    it('should set intensity', () => {
-        const testLight = new DIVEPointLight();
-        testLight.SetIntensity(1.0);
-        expect((testLight.children[0] as PointLight).intensity).toBe(1.0);
-        testLight.SetIntensity(0.6);
-        expect((testLight.children[0] as PointLight).intensity).toBe(0.6);
-    });
-
-    it('should set color', () => {
-        const testLight = new DIVEPointLight();
-        testLight.SetColor({ test: true } as unknown as Color);
-        expect((testLight.children[0] as PointLight).color).toEqual({
-            test: true,
-        });
-    });
-
-    it('should set enabled', () => {
-        const testLight = new DIVEPointLight();
-        testLight.SetEnabled(false);
-        expect(testLight.children[0].visible).toBe(false);
-    });
-
-    it('should onMove', () => {
-        const testLight = new DIVEPointLight();
-        testLight.userData.id = 'something';
-        expect(() => testLight.onMove()).not.toThrow();
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => testLight.onMove()).not.toThrow();
-    });
-
-    it('should onSelect', () => {
-        const testLight = new DIVEPointLight();
-        testLight.userData.id = 'something';
-        expect(() => testLight.onSelect()).not.toThrow();
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => testLight.onSelect()).not.toThrow();
-    });
-
-    it('should onDeselect', () => {
-        const testLight = new DIVEPointLight();
-        testLight.userData.id = 'something';
-        expect(() => testLight.onDeselect()).not.toThrow();
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => testLight.onDeselect()).not.toThrow();
-    });
-});

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

@@ -1,47 +0,0 @@
-import DIVESceneLight from '../SceneLight';
-import { DIVECommunication } from '../../com/Communication';
-import { Color, Object3D } from 'three';
-
-jest.mock('../../com/Communication.ts', () => {
-    return {
-        DIVECommunication: {
-            get: jest.fn(() => {
-                return {
-                    PerformAction: jest.fn(),
-                };
-            }),
-        },
-    };
-});
-
-jest.spyOn(DIVECommunication, 'get').mockReturnValue({
-    PerformAction: jest.fn(),
-} as unknown as DIVECommunication);
-
-describe('dive/light/DIVESceneLight', () => {
-    it('should instantiate', () => {
-        const testLight = new DIVESceneLight();
-        expect(testLight).toBeDefined();
-        expect(testLight.children).toHaveLength(2);
-    });
-
-    it('should set intensity', () => {
-        const testLight = new DIVESceneLight();
-        expect(() => testLight.SetIntensity(1.0)).not.toThrow();
-        expect(() => testLight.SetIntensity(0.6)).not.toThrow();
-    });
-
-    it('should set color', () => {
-        const testLight = new DIVESceneLight();
-        expect(() =>
-            testLight.SetColor({ test: true } as unknown as Color),
-        ).not.toThrow();
-    });
-
-    it('should set enabled', () => {
-        const testLight = new DIVESceneLight();
-        testLight.SetEnabled(false);
-        expect(testLight.children[0].visible).toBe(false);
-        expect(testLight.children[1].visible).toBe(false);
-    });
-});

package/src/loader/Loader.ts

@@ -1,48 +0,0 @@
-import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';
-import { USDZLoader } from 'three/examples/jsm/loaders/USDZLoader';
-import { Object3D } from 'three';
-import { type FileType, SUPPORTED_FILE_TYPES } from '../types';
-
-export class Loader {
-    private _gltfLoader: GLTFLoader;
-    private _usdzLoader: USDZLoader;
-
-    constructor() {
-        this._gltfLoader = new GLTFLoader();
-        this._usdzLoader = new USDZLoader();
-    }
-
-    public async load(uri: string): Promise<Object3D> {
-        const type = this._getFileTypeFromUri(uri);
-        return this._load(uri, type);
-    }
-
-    private _getFileTypeFromUri(uri: string): FileType {
-        const extension = uri.split('.').pop()?.toLowerCase() as FileType;
-        if (!extension || !SUPPORTED_FILE_TYPES.includes(extension)) {
-            throw new Error(`Unsupported file type: ${extension}`);
-        }
-        return extension;
-    }
-
-    private async _load(uri: string, type: FileType): Promise<Object3D> {
-        switch (type) {
-            case 'glb':
-            case 'gltf': {
-                return this._loadGltf(uri);
-            }
-            case 'usdz': {
-                return this._loadUsdz(uri);
-            }
-        }
-    }
-
-    private async _loadGltf(uri: string): Promise<Object3D> {
-        const gltf = await this._gltfLoader.loadAsync(uri);
-        return gltf.scene;
-    }
-
-    private async _loadUsdz(uri: string): Promise<Object3D> {
-        return this._usdzLoader.loadAsync(uri);
-    }
-}

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),
-    );
-}