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

package/src/interface/Movable.ts

@@ -1,12 +0,0 @@
-/**
- * Interface for objects that can be moved in the scene.
- *
- * @module
- */
-
-export class DIVEMovable {
-    readonly isMovable: true = true;
-    public onMoveStart?(): void;
-    public onMove?(): void;
-    public onMoveEnd?(): void;
-}

package/src/interface/Rotatable.ts

@@ -1,10 +0,0 @@
-/**
- * Interface for objects that can be rotated in the scene.
- *
- * @module
- */
-
-export interface DIVERotatable {
-    isRotatable: true;
-    onRotate?: () => void;
-}

package/src/interface/Scalable.ts

@@ -1,10 +0,0 @@
-/**
- * Interface for objects that can be scaled in the scene.
- *
- * @module
- */
-
-export interface DIVEScalable {
-    isScalable: true;
-    onScale?: () => void;
-}

package/src/interface/Selectable.ts

@@ -1,11 +0,0 @@
-/**
- * Interface for objects that can be selected in the scene.
- *
- * @module
- */
-
-export class DIVESelectable {
-    readonly isSelectable: true = true;
-    public onSelect?(): void;
-    public onDeselect?(): void;
-}

package/src/io/IO.ts

@@ -1,62 +0,0 @@
-import { DIVEGLTFIO } from './gltf/GLTFIO';
-
-import { type DIVESceneFileType } from '../types';
-import { type DIVEScene } from '../scene/Scene';
-
-export class DIVEIO {
-    private _scene: DIVEScene;
-
-    private _gltfIO: DIVEGLTFIO;
-
-    constructor(scene: DIVEScene) {
-        this._scene = scene;
-
-        this._gltfIO = new DIVEGLTFIO();
-    }
-
-    public Import<FileType extends keyof DIVESceneFileType>(
-        type: FileType,
-        url: string,
-    ): Promise<DIVESceneFileType[FileType] | null> {
-        switch (type) {
-            case 'glb': {
-                return this._gltfIO.Import(url).catch((error) => {
-                    console.error(error);
-                    return null;
-                });
-            }
-
-            default: {
-                console.error('DIVEIO.Import: Unsupported file type: ' + type);
-                return Promise.reject();
-            }
-        }
-    }
-
-    public Export<FileType extends keyof DIVESceneFileType>(
-        type: FileType,
-    ): Promise<string | null> {
-        switch (type) {
-            case 'glb': {
-                return this._gltfIO
-                    .Export(this._scene, true, true)
-                    .then((data) => {
-                        return this._createBlobURL(data);
-                    })
-                    .catch((error) => {
-                        console.error(error);
-                        return null;
-                    });
-            }
-
-            default: {
-                console.error('DIVEIO.Export: Unsupported file type: ' + type);
-                return Promise.reject();
-            }
-        }
-    }
-
-    private _createBlobURL(data: ArrayBuffer): string {
-        return URL.createObjectURL(new Blob([data]));
-    }
-}

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

@@ -1,116 +0,0 @@
-import { DIVEIO } from '../IO';
-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 handle rejection from gltf io import', async () => {
-        jest.spyOn(console, 'error').mockImplementationOnce(() => {});
-        jest.spyOn(testIO['_gltfIO'], 'Import').mockRejectedValueOnce(
-            'THIS_IS_A_TEST_ERROR',
-        );
-
-        expect(testIO.Import('glb', 'test.glb')).resolves.toEqual(null);
-    });
-
-    it('should reject when importing with unsupported file type', async () => {
-        const spy = jest
-            .spyOn(console, 'error')
-            .mockImplementationOnce(() => {});
-
-        expect(
-            testIO.Import('THIS_IS_NOT_A_VALID_FILE_TYPE' as 'glb', 'test.glb'),
-        ).rejects.not.toBeDefined();
-        expect(spy).toHaveBeenCalled();
-    });
-
-    it('should export to URL', async () => {
-        const mockObject = {};
-        const mockURL = 'blob://mockURL';
-        jest.spyOn(testIO['_gltfIO'], 'Export').mockResolvedValueOnce(
-            mockObject,
-        );
-
-        URL.createObjectURL = jest.fn().mockReturnValueOnce(mockURL);
-
-        const result = await testIO.Export('glb');
-        expect(result).toBeDefined();
-        expect(console.error).not.toHaveBeenCalled();
-    });
-
-    it('should handle rejection from gltf io export', async () => {
-        const spy = jest
-            .spyOn(console, 'error')
-            .mockImplementationOnce(() => {});
-        jest.spyOn(testIO['_gltfIO'], 'Export').mockRejectedValueOnce(
-            'THIS_IS_A_TEST_ERROR',
-        );
-
-        expect(testIO.Export('glb')).resolves.toEqual(null);
-    });
-
-    it('should reject when exporting with unsupported file type', async () => {
-        const spy = jest
-            .spyOn(console, 'error')
-            .mockImplementationOnce(() => {});
-
-        expect(
-            testIO.Export('THIS_IS_NOT_A_VALID_FILE_TYPE' as 'glb'),
-        ).rejects.not.toBeDefined();
-        expect(spy).toHaveBeenCalled();
-    });
-});

package/src/io/gltf/GLTFIO.ts

@@ -1,56 +0,0 @@
-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> {
-        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 }> {
-        if (binary) {
-            // export as binary 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 }>;
-        }
-    }
-}

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

@@ -1,108 +0,0 @@
-import { Object3D } from 'three';
-import { DIVEGLTFIO } from '../GLTFIO';
-
-import { type GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
-
-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,
-        );
-
-        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);
-                }),
-        );
-
-        const onProgress = jest.fn();
-
-        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(
-            {},
-        );
-
-        const json = await testGLTFIO.Export(mockObject, false, false);
-        expect(json).toBeDefined();
-
-        // export as array buffer
-        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,
-        );
-        expect(binaryOnlyVisible).toBeDefined();
-    });
-});

package/src/light/AmbientLight.ts

@@ -1,39 +0,0 @@
-import { AmbientLight, Color, Object3D } from 'three';
-import { PRODUCT_LAYER_MASK } from '../constant/VisibilityLayerMask';
-
-/**
- * A basic ambient light.
- *
- * Can change the color, intensity, and visibility of the light.
- *
- * @module
- */
-
-export default class DIVEAmbientLight extends Object3D {
-    readonly isDIVELight: true = true;
-    readonly isDIVEAmbientLight: true = true;
-
-    private _light: AmbientLight;
-
-    constructor() {
-        super();
-
-        this.name = 'DIVEAmbientLight';
-
-        this._light = new AmbientLight(0xffffff, 1);
-        this._light.layers.mask = PRODUCT_LAYER_MASK;
-        this.add(this._light);
-    }
-
-    public SetColor(color: Color): void {
-        this._light.color = color;
-    }
-
-    public SetIntensity(intensity: number): void {
-        this._light.intensity = intensity;
-    }
-
-    public SetEnabled(enabled: boolean): void {
-        this._light.visible = enabled;
-    }
-}

package/src/light/PointLight.ts

@@ -1,115 +0,0 @@
-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 { DIVEMovable } from '../interface/Movable';
-import { DIVESelectable } from '../interface/Selectable';
-import type { TransformControls } from 'three/examples/jsm/controls/TransformControls';
-
-/**
- * A basic point light.
- *
- * Can change the color, intensity, and visibility of the light.
- *
- * Can be moved and selected.
- *
- * @module
- */
-
-export default class DIVEPointLight
-    extends Object3D
-    implements DIVESelectable, DIVEMovable
-{
-    readonly isDIVELight: true = true;
-    readonly isDIVEPointLight: true = true;
-    readonly isMovable: true = true;
-    readonly isSelectable: true = true;
-
-    public gizmo: TransformControls | null = null;
-
-    private light: PointLight;
-    private mesh: Mesh;
-
-    constructor() {
-        super();
-
-        this.name = 'DIVEPointLight';
-
-        this.light = new PointLight(0xffffff, 1);
-
-        this.light.layers.mask = PRODUCT_LAYER_MASK;
-
-        this.light.castShadow = true;
-        this.light.shadow.mapSize.width = 512;
-        this.light.shadow.mapSize.height = 512;
-        this.add(this.light);
-
-        const geoSize = 0.1;
-
-        const geometry = new SphereGeometry(
-            geoSize,
-            geoSize * 320,
-            geoSize * 320,
-        );
-
-        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;
-
-        this.add(this.mesh);
-    }
-
-    public SetColor(color: Color): void {
-        this.light.color = color;
-
-        (this.mesh.material as MeshBasicMaterial).color = color;
-    }
-
-    public SetIntensity(intensity: number): void {
-        this.light.intensity = intensity;
-
-        (this.mesh.material as MeshBasicMaterial).opacity =
-            intensity > 0.8 ? 0.8 : intensity * 0.8;
-    }
-
-    public SetEnabled(enabled: boolean): void {
-        this.light.visible = enabled;
-    }
-
-    public onMove(): void {
-        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 },
-        );
-    }
-
-    public onDeselect(): void {
-        DIVECommunication.get(this.userData.id)?.PerformAction(
-            'DESELECT_OBJECT',
-            { id: this.userData.id },
-        );
-    }
-}

package/src/light/SceneLight.ts

@@ -1,63 +0,0 @@
-import { PRODUCT_LAYER_MASK } from '../constant/VisibilityLayerMask.ts';
-import { Color, DirectionalLight, HemisphereLight, Object3D } from 'three';
-
-/**
- * A complex scene light.
- *
- * Can change the color, intensity, and visibility of the light.
- *
- * @module
- */
-
-export default class DIVESceneLight extends Object3D {
-    readonly isDIVELight: true = true;
-    readonly isDIVESceneLight: true = true;
-
-    private _hemiLight: HemisphereLight;
-    private _dirLight: DirectionalLight;
-
-    constructor() {
-        super();
-
-        this.name = 'DIVESceneLight';
-
-        this._hemiLight = new HemisphereLight(0xffffff, 0xffffff, 2);
-        this._hemiLight.layers.mask = PRODUCT_LAYER_MASK;
-        this._hemiLight.position.set(0, 50, 0);
-        this.add(this._hemiLight);
-
-        this._dirLight = new DirectionalLight(0xffffff, 3);
-        this._dirLight.layers.mask = PRODUCT_LAYER_MASK;
-        this._dirLight.position.set(1, 1.75, 1);
-        this._dirLight.position.multiplyScalar(30);
-        this._dirLight.castShadow = true;
-
-        this._dirLight.shadow.mapSize.width = 2048;
-        this._dirLight.shadow.mapSize.height = 2048;
-
-        const d = 5;
-
-        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.far = 3500;
-        this.add(this._dirLight);
-    }
-
-    public SetColor(color: Color): void {
-        this._hemiLight.color = color;
-        this._dirLight.color = color;
-    }
-
-    public SetIntensity(intensity: number): void {
-        this._hemiLight.intensity = intensity * 2;
-        this._dirLight.intensity = intensity * 3;
-    }
-
-    public SetEnabled(enabled: boolean): void {
-        this._hemiLight.visible = enabled;
-        this._dirLight.visible = enabled;
-    }
-}

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

@@ -1,29 +0,0 @@
-import { AmbientLight, Color, Object3D } from 'three';
-import DIVEAmbientLight from '../AmbientLight';
-
-describe('dive/light/DIVEAmbientLight', () => {
-    it('should instantiate', () => {
-        const testLight = new DIVEAmbientLight();
-        expect(testLight).toBeDefined();
-    });
-
-    it('should set intensity', () => {
-        const testLight = new DIVEAmbientLight();
-        testLight.SetIntensity(1.0);
-        expect((testLight.children[0] as AmbientLight).intensity).toBe(1.0);
-    });
-
-    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,
-        });
-    });
-
-    it('should set enabled', () => {
-        const testLight = new DIVEAmbientLight();
-        testLight.SetEnabled(false);
-        expect(testLight.children[0].visible).toBe(false);
-    });
-});