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

package/src/module/Module.ts

@@ -1,45 +0,0 @@
-export class DIVEModule<T> {
-    constructor(
-        private _path: string,
-        private _ctor: string,
-    ) {}
-
-    private _promise: Promise<T> | null = null;
-    private _instance: T | null = null;
-
-    public async get(): Promise<T> {
-        // if we already have an instance, return it
-        if (this._instance) {
-            return Promise.resolve(this._instance);
-        }
-
-        // if we already have a loading process ongoing, return the already created promise
-        if (this._promise) {
-            return this._promise;
-        }
-
-        // if we don't have a promise yet, it means that we are not already loading the module
-        this._promise = (async () => {
-            const module = await import(this._path);
-
-            const ModuleConstructor = module[this._ctor];
-
-            if (!ModuleConstructor) {
-                throw new Error(
-                    `DIVE: Module class ${this._ctor} not found in ${this._path}`,
-                );
-            }
-
-            if (typeof ModuleConstructor !== 'function') {
-                throw new Error(
-                    `DIVE: Module at ${this._path} does not export a valid constructor (${this._ctor} wanted)`,
-                );
-            }
-
-            this._instance = new ModuleConstructor() as T;
-            return this._instance;
-        })();
-
-        return this._promise;
-    }
-}

package/src/module/__test__/Module.test.ts

@@ -1,54 +0,0 @@
-import { DIVEModule } from '../Module';
-
-jest.mock('/mock/path', () => mockModule, { virtual: true });
-
-const mockModule: Record<string, any> = {};
-
-describe('dive/module/DIVEModule', () => {
-    beforeEach(() => {
-        // Reset the mock module before each test
-        Object.keys(mockModule).forEach((key) => delete mockModule[key]);
-    });
-
-    it('should return the same instance on multiple calls to get()', async () => {
-        mockModule.TestClass = class TestClass {};
-        const diveModule = new DIVEModule('/mock/path', 'TestClass');
-
-        const instance1 = await diveModule.get();
-        const instance2 = await diveModule.get();
-
-        expect(instance1).toBe(instance2);
-    });
-
-    it('should throw an error if the constructor is not found', async () => {
-        const diveModule = new DIVEModule('/mock/path', 'NonExistentClass');
-
-        await expect(diveModule.get()).rejects.toThrow(
-            'DIVE: Module class NonExistentClass not found in /mock/path',
-        );
-    });
-
-    it('should throw an error if the constructor is not a function', async () => {
-        mockModule.InvalidClass = {};
-        const diveModule = new DIVEModule('/mock/path', 'InvalidClass');
-
-        await expect(diveModule.get()).rejects.toThrow(
-            'DIVE: Module at /mock/path does not export a valid constructor (InvalidClass wanted)',
-        );
-    });
-
-    it('should only load the module once even with concurrent calls to get()', async () => {
-        mockModule.TestClass = class TestClass {};
-        const diveModule = new DIVEModule('/mock/path', 'TestClass');
-
-        const [
-            instance1,
-            instance2,
-        ] = await Promise.all([
-            diveModule.get(),
-            diveModule.get(),
-        ]);
-
-        expect(instance1).toBe(instance2);
-    });
-});

package/src/node/Node.ts

@@ -1,100 +0,0 @@
-import { Box3, Object3D, Vector3, type Vector3Like } from 'three';
-import { PRODUCT_LAYER_MASK } from '../constant/VisibilityLayerMask';
-import { DIVECommunication } from '../com/Communication';
-
-import { DIVEMovable } from '../interface/Movable';
-import { DIVESelectable } from '../interface/Selectable';
-import { type TransformControls } from 'three/examples/jsm/controls/TransformControls';
-import { type DIVEGroup } from '../group/Group';
-import { applyMixins } from '../helper/applyMixins/applyMixins';
-
-export class DIVENode extends applyMixins(Object3D, [
-    DIVESelectable,
-    DIVEMovable,
-]) {
-    readonly isDIVENode: true = true;
-
-    public gizmo: TransformControls | null = null;
-
-    protected _positionWorldBuffer: Vector3;
-    protected _boundingBox: Box3;
-
-    constructor() {
-        super();
-
-        this.layers.mask = PRODUCT_LAYER_MASK;
-
-        this._positionWorldBuffer = new Vector3();
-        this._boundingBox = new Box3();
-    }
-
-    public SetPosition(position: Vector3Like): void {
-        // if there is no parent, the object will be attached later and keep it's world position
-        if (!this.parent) {
-            this.position.set(position.x, position.y, position.z);
-            return;
-        }
-
-        // if we have a parent, we have to calculate the position in the parent's coordinate system to keep the world position
-        const newPosition = new Vector3(position.x, position.y, position.z);
-        this.position.copy(this.parent.worldToLocal(newPosition));
-
-        if ('isDIVEGroup' in this.parent) {
-            (this.parent as unknown as DIVEGroup).UpdateLineTo(this);
-        }
-    }
-
-    public SetRotation(rotation: Vector3Like): void {
-        this.rotation.set(rotation.x, rotation.y, rotation.z);
-    }
-
-    public SetScale(scale: Vector3Like): void {
-        this.scale.set(scale.x, scale.y, scale.z);
-    }
-
-    public SetVisibility(visible: boolean): void {
-        this.visible = visible;
-    }
-
-    public SetToWorldOrigin(): void {
-        this.position.set(0, 0, 0);
-        DIVECommunication.get(this.userData.id)?.PerformAction(
-            'UPDATE_OBJECT',
-            {
-                id: this.userData.id,
-                position: this.getWorldPosition(this._positionWorldBuffer),
-                rotation: this.rotation,
-                scale: this.scale,
-            },
-        );
-    }
-
-    /**
-     * Can be called when the object is moved from a foreign object (gizmo, parent, etc.) to update the object's position.
-     */
-    public onMove(): void {
-        DIVECommunication.get(this.userData.id)?.PerformAction(
-            'UPDATE_OBJECT',
-            {
-                id: this.userData.id,
-                position: this.getWorldPosition(this._positionWorldBuffer),
-                rotation: this.rotation,
-                scale: this.scale,
-            },
-        );
-    }
-
-    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/node/__test__/Node.test.ts

@@ -1,120 +0,0 @@
-import { DIVENode } from '../Node';
-import { DIVECommunication } from '../../com/Communication';
-import { Vector3, Box3, Mesh, Color, Euler } from 'three';
-import { type DIVEGroup } from '../../group/Group';
-
-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);
-
-let node: DIVENode;
-
-describe('dive/node/DIVENode', () => {
-    beforeEach(() => {
-        node = new DIVENode();
-    });
-
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-
-    it('should instantiate', () => {
-        expect(node).toBeDefined();
-    });
-
-    it('should set position', () => {
-        const spySet = jest.spyOn(node.position, 'set');
-        const spyCopy = jest.spyOn(node.position, 'copy');
-
-        // without a parent, the node should only set it's local position
-        node.parent = null;
-        expect(() => node.SetPosition({ x: 1, y: 2, z: 3 })).not.toThrow();
-        expect(spySet).toHaveBeenCalledWith(1, 2, 3);
-        expect(spyCopy).not.toHaveBeenCalled();
-
-        // with a parent, the node should set it's position relative to the parent
-        spySet.mockClear();
-        spyCopy.mockClear();
-        node.parent = {
-            worldToLocal: jest.fn(() => new Vector3(4, 5, 6)),
-            isDIVEGroup: true,
-            UpdateLineTo: jest.fn(),
-        } as unknown as DIVENode;
-        const spyUpdateLineTo = jest.spyOn(
-            node.parent as DIVEGroup,
-            'UpdateLineTo',
-        );
-        expect(() => node.SetPosition({ x: 4, y: 5, z: 6 })).not.toThrow();
-        expect(spySet).not.toHaveBeenCalled();
-        expect(spyCopy).toHaveBeenCalledWith(
-            expect.objectContaining({ x: 4, y: 5, z: 6 }),
-        );
-    });
-
-    it('should set rotation', () => {
-        expect(() => node.SetRotation({ x: 0, y: 0, z: 0 })).not.toThrow();
-    });
-
-    it('should set scale', () => {
-        expect(() => node.SetScale({ x: 1, y: 1, z: 1 })).not.toThrow();
-    });
-
-    it('should set visibility', () => {
-        expect(() => node.SetVisibility(true)).not.toThrow();
-    });
-
-    it('should set to world origin', () => {
-        node.userData.id = 'something';
-
-        expect(() => node.SetToWorldOrigin()).not.toThrow();
-        expect(node.position.x).toBe(0);
-        expect(node.position.y).toBe(0);
-        expect(node.position.z).toBe(0);
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => node.SetToWorldOrigin()).not.toThrow();
-    });
-
-    it('should onMove', () => {
-        node.userData.id = 'something';
-        node.parent = {
-            isDIVEGroup: true,
-            UpdateLineTo: jest.fn(),
-        } as unknown as DIVENode;
-
-        expect(() => node.onMove()).not.toThrow();
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => node.onMove()).not.toThrow();
-    });
-
-    it('should onSelect', () => {
-        node.userData.id = 'something';
-
-        expect(() => node.onSelect()).not.toThrow();
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => node.onSelect()).not.toThrow();
-    });
-
-    it('should onDeselect', () => {
-        node.userData.id = 'something';
-
-        expect(() => node.onDeselect()).not.toThrow();
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => node.onDeselect()).not.toThrow();
-    });
-});

package/src/primitive/Primitive.ts

@@ -1,299 +0,0 @@
-import {
-    BoxGeometry,
-    BufferAttribute,
-    BufferGeometry,
-    Color,
-    ConeGeometry,
-    CylinderGeometry,
-    Mesh,
-    MeshStandardMaterial,
-    Raycaster,
-    SphereGeometry,
-    Vector3,
-} from 'three';
-import { PRODUCT_LAYER_MASK } from '../constant/VisibilityLayerMask';
-import { findSceneRecursive } from '../helper/findSceneRecursive/findSceneRecursive';
-import { DIVENode } from '../node/Node';
-import { type COMGeometry, type COMMaterial } from '../com/types';
-import { DIVECommunication } from '../com/Communication';
-
-/**
- * A basic model class.
- *
- * It does calculate it's own bounding box which is used for positioning on the floor.
- *
- * Can be moved and selected.
- *
- * @module
- */
-export class DIVEPrimitive extends DIVENode {
-    readonly isDIVEPrimitive: true = true;
-
-    private _mesh: Mesh;
-
-    constructor() {
-        super();
-
-        this._mesh = new Mesh();
-        this._mesh.layers.mask = PRODUCT_LAYER_MASK;
-        this._mesh.castShadow = true;
-        this._mesh.receiveShadow = true;
-        this._mesh.material = new MeshStandardMaterial();
-        this.add(this._mesh);
-    }
-
-    public SetGeometry(geometry: COMGeometry): void {
-        const geo = this.assembleGeometry(geometry);
-        if (!geo) return;
-
-        this._mesh.geometry = geo;
-        this._boundingBox.setFromObject(this._mesh);
-    }
-
-    public SetMaterial(material: Partial<COMMaterial>): void {
-        const primitiveMaterial = this._mesh.material as MeshStandardMaterial;
-
-        if (material.vertexColors !== undefined) {
-            primitiveMaterial.vertexColors = material.vertexColors;
-        }
-
-        // apply color if supplied
-        if (material.color !== undefined) {
-            primitiveMaterial.color = new Color(material.color);
-        }
-
-        // apply albedo map if supplied
-        if (material.map !== undefined) {
-            primitiveMaterial.map = material.map;
-        }
-
-        // apply normal map
-        if (material.normalMap !== undefined) {
-            primitiveMaterial.normalMap = material.normalMap;
-        }
-
-        // set roughness value
-        // if supplied, apply roughness map
-        // if we applied a roughness map, set roughness to 1.0
-        if (material.roughness !== undefined) {
-            primitiveMaterial.roughness = material.roughness;
-        }
-
-        if (material.roughnessMap !== undefined) {
-            primitiveMaterial.roughnessMap = material.roughnessMap;
-
-            if (primitiveMaterial.roughnessMap) {
-                primitiveMaterial.roughness = 1.0;
-            }
-        }
-
-        // set metalness value
-        // if supplied, apply metalness map
-        // if we applied a metalness map, set metalness to 1.0
-        if (material.metalness !== undefined) {
-            primitiveMaterial.metalness = material.metalness;
-        }
-
-        if (material.metalnessMap !== undefined) {
-            primitiveMaterial.metalnessMap = material.metalnessMap;
-
-            if (primitiveMaterial.metalnessMap) {
-                primitiveMaterial.metalness = 0.0;
-            }
-        }
-
-        // if the mesh is already set, update the material
-        if (this._mesh) this._mesh.material = primitiveMaterial;
-    }
-
-    public PlaceOnFloor(): void {
-        // calculate and temporary save world position
-        const worldPos = this.getWorldPosition(this._positionWorldBuffer);
-        const oldWorldPos = worldPos.clone();
-
-        // compute the bounding box
-        this._mesh?.geometry?.computeBoundingBox();
-        const meshBB = this._mesh?.geometry?.boundingBox;
-
-        // subtract the bounding box min y axis value from the world position y value
-        if (!meshBB || !this._mesh) return;
-        worldPos.y = worldPos.y - this._mesh.localToWorld(meshBB.min.clone()).y;
-
-        // skip any action when the position did not change
-        if (worldPos.y === oldWorldPos.y) return;
-
-        DIVECommunication.get(this.userData.id)?.PerformAction(
-            'UPDATE_OBJECT',
-            {
-                id: this.userData.id,
-                position: worldPos,
-                rotation: this.rotation,
-                scale: this.scale,
-            },
-        );
-    }
-
-    public DropIt(): void {
-        if (!this.parent) {
-            console.warn(
-                'DIVEPrimitive: DropIt() called on a model that is not in the scene.',
-                this,
-            );
-            return;
-        }
-
-        // calculate the bottom center of the bounding box
-        const bottomY = this._boundingBox.min.y * this.scale.y;
-        const bbBottomCenter = this.localToWorld(
-            this._boundingBox.getCenter(new Vector3()).multiply(this.scale),
-        );
-        bbBottomCenter.y = bottomY + this.position.y;
-
-        // set up raycaster and raycast all scene objects (product layer)
-        const raycaster = new Raycaster(bbBottomCenter, new Vector3(0, -1, 0));
-        raycaster.layers.mask = PRODUCT_LAYER_MASK;
-        const intersections = raycaster.intersectObjects(
-            findSceneRecursive(this).Root.children,
-            true,
-        );
-
-        // if we hit something, move the model to the top on the hit object's bounding box
-        if (intersections.length > 0) {
-            const mesh = intersections[0].object as Mesh;
-            mesh.geometry.computeBoundingBox();
-            const meshBB = mesh.geometry.boundingBox!;
-            const worldPos = mesh.localToWorld(meshBB.max.clone());
-
-            const oldPos = this.position.clone();
-            const newPos = this.position
-                .clone()
-                .setY(worldPos.y)
-                .sub(new Vector3(0, bottomY, 0));
-            this.position.copy(newPos);
-
-            // if the position changed, update the object in communication
-            if (this.position.y === oldPos.y) return;
-
-            this.onMove();
-        }
-    }
-
-    private assembleGeometry(geometry: COMGeometry): BufferGeometry | null {
-        // reset material to smooth shading
-        (this._mesh.material as MeshStandardMaterial).flatShading = false;
-
-        switch (geometry.name.toLowerCase()) {
-            case 'cylinder':
-                return this.createCylinderGeometry(geometry);
-            case 'sphere':
-                return this.createSphereGeometry(geometry);
-            case 'pyramid':
-                // set material to flat shading for pyramid
-                (this._mesh.material as MeshStandardMaterial).flatShading =
-                    true;
-                return this.createPyramidGeometry(geometry);
-            case 'cube':
-            case 'box':
-                return this.createBoxGeometry(geometry);
-            case 'cone':
-                return this.createConeGeometry(geometry);
-            case 'wall':
-                return this.createWallGeometry(geometry);
-            case 'plane':
-                return this.createPlaneGeometry(geometry);
-            default: {
-                console.warn(
-                    'DIVEPrimitive.assembleGeometry: Invalid geometry type:',
-                    geometry.name.toLowerCase(),
-                );
-                return null;
-            }
-        }
-    }
-
-    private createCylinderGeometry(geometry: COMGeometry): BufferGeometry {
-        const geo = new CylinderGeometry(
-            geometry.width / 2,
-            geometry.width / 2,
-            geometry.height,
-            64,
-        );
-        geo.translate(0, geometry.height / 2, 0);
-        return geo;
-    }
-
-    private createSphereGeometry(geometry: COMGeometry): BufferGeometry {
-        const geo = new SphereGeometry(geometry.width / 2, 256, 256);
-        return geo;
-    }
-
-    private createPyramidGeometry(geometry: COMGeometry): BufferGeometry {
-        // prettier-multiline-arrays-next-line-pattern: 3
-        const vertices = new Float32Array([
-            -geometry.width / 2, 0, -geometry.depth / 2, // 0
-            geometry.width / 2, 0, -geometry.depth / 2, // 1
-            geometry.width / 2, 0, geometry.depth / 2, // 2
-            -geometry.width / 2, 0, geometry.depth / 2, // 3
-            0, geometry.height, 0,
-        ]);
-
-        // prettier-multiline-arrays-next-line-pattern: 3
-        const indices = new Uint16Array([
-            0, 1, 2,
-            0, 2, 3,
-            0, 4, 1,
-            1, 4, 2,
-            2, 4, 3,
-            3, 4, 0,
-        ]);
-
-        const geometryBuffer = new BufferGeometry();
-        geometryBuffer.setAttribute(
-            'position',
-            new BufferAttribute(vertices, 3),
-        );
-        geometryBuffer.setIndex(new BufferAttribute(indices, 1));
-        geometryBuffer.computeVertexNormals();
-
-        geometryBuffer.computeBoundingBox();
-        geometryBuffer.computeBoundingSphere();
-        return geometryBuffer;
-    }
-
-    private createBoxGeometry(geometry: COMGeometry): BufferGeometry {
-        const geo = new BoxGeometry(
-            geometry.width,
-            geometry.height,
-            geometry.depth,
-        );
-        geo.translate(0, geometry.height / 2, 0);
-        return geo;
-    }
-
-    private createConeGeometry(geometry: COMGeometry): BufferGeometry {
-        const geo = new ConeGeometry(geometry.width / 2, geometry.height, 256);
-        geo.translate(0, geometry.height / 2, 0);
-        return geo;
-    }
-
-    private createWallGeometry(geometry: COMGeometry): BufferGeometry {
-        const geo = new BoxGeometry(
-            geometry.width,
-            geometry.height,
-            geometry.depth || 0.05,
-            16,
-        );
-        geo.translate(0, geometry.height / 2, 0);
-        return geo;
-    }
-
-    private createPlaneGeometry(geometry: COMGeometry): BufferGeometry {
-        const geo = new BoxGeometry(
-            geometry.width,
-            geometry.height,
-            geometry.depth,
-        );
-        geo.translate(0, geometry.height / 2, 0);
-        return geo;
-    }
-}