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

package/src/group/__test__/Group.test.ts

@@ -1,212 +0,0 @@
-import { Object3D, type Vector3Like } from 'three';
-import { DIVECommunication } from '../../com/Communication';
-import { type DIVENode } from '../../node/Node';
-import { DIVEGroup } from '../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 group: DIVEGroup;
-
-Object3D.prototype.attach = jest.fn();
-
-describe('dive/group/DIVEGroup', () => {
-    beforeEach(() => {
-        group = new DIVEGroup();
-    });
-
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-
-    it('should instantiate', () => {
-        expect(group).toBeDefined();
-    });
-
-    it('should add an object', () => {
-        const mockObject = new DIVEGroup();
-
-        expect(() => group.attach(mockObject)).not.toThrow();
-        expect(group.members).toContainEqual(
-            expect.objectContaining(mockObject),
-        );
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => group.attach(mockObject)).not.toThrow();
-    });
-
-    it('should remove an object', () => {
-        const mockObject = new DIVEGroup();
-
-        expect(() => group.remove(mockObject)).not.toThrow();
-        expect(group.children).not.toContain(mockObject);
-        expect(group.members).not.toContain(mockObject);
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => group.remove(mockObject)).not.toThrow();
-    });
-
-    it('should set lines visibility', () => {
-        expect(() => group.SetLinesVisibility(true)).not.toThrow();
-
-        const mockObject = new DIVEGroup();
-        expect(() => group.SetLinesVisibility(false, mockObject)).not.toThrow();
-
-        expect(() => group.attach(mockObject)).not.toThrow();
-        expect(() => group.SetLinesVisibility(false)).not.toThrow();
-
-        expect(() => group.SetLinesVisibility(true, mockObject)).not.toThrow();
-    });
-
-    it('update lines', () => {
-        const mockObject = new DIVEGroup();
-        expect(() => group.UpdateLineTo(mockObject)).not.toThrow();
-
-        expect(() => group.attach(mockObject)).not.toThrow();
-        expect(() => group.UpdateLineTo(mockObject)).not.toThrow();
-    });
-
-    it('should onMove', () => {
-        group.userData.id = 'something';
-
-        expect(() => group.onMove()).not.toThrow();
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => group.onMove()).not.toThrow();
-    });
-
-    it('should onSelect', () => {
-        group.userData.id = 'something';
-
-        expect(() => group.onSelect()).not.toThrow();
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => group.onSelect()).not.toThrow();
-    });
-
-    it('should onDeselect', () => {
-        group.userData.id = 'something';
-
-        expect(() => group.onDeselect()).not.toThrow();
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => group.onDeselect()).not.toThrow();
-    });
-
-    it('should onMove', () => {
-        group.userData.id = 'something';
-
-        expect(() => group.onMove()).not.toThrow();
-
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => group.onMove()).not.toThrow();
-    });
-
-    it('should call onMove on members with isDIVENode', () => {
-        // Create mock members
-        const diveNode1: DIVENode = {
-            isDIVENode: true,
-            onMove: jest.fn(),
-        } as unknown as DIVENode;
-
-        const diveNode2: DIVENode = {
-            isDIVENode: true,
-            onMove: jest.fn(),
-        } as unknown as DIVENode;
-
-        const member1: DIVENode = {
-            // Define other properties/methods if necessary
-        } as unknown as DIVENode;
-
-        const member2: DIVENode = {
-            // Define other properties/methods if necessary
-        } as unknown as DIVENode;
-
-        // Assign the _members array (assuming it's protected or public for testing)
-        // If _members is private, you might need to use a different approach or modify the class for testability
-        (group as any)._members = [
-            diveNode1,
-            member1,
-            diveNode2,
-            member2,
-        ];
-
-        const position: Vector3Like = { x: 4, y: 5, z: 6 };
-        group.SetPosition(position);
-
-        // Check that onMove was called on diveNode1 and diveNode2
-        expect(diveNode1.onMove).toHaveBeenCalled();
-        expect(diveNode2.onMove).toHaveBeenCalled();
-
-        // Ensure onMove was not called on other members
-        // Since member1 and member2 don't have onMove, there's nothing to assert here
-        // If members have onMove, you should mock and verify they are not called
-    });
-
-    it('should not call onMove on members without isDIVENode', () => {
-        // Create mock members without isDIVENode
-        const member1: DIVENode = {
-            // Define other properties/methods if necessary
-        } as unknown as DIVENode;
-
-        const member2: DIVENode = {
-            // Define other properties/methods if necessary
-        } as unknown as DIVENode;
-
-        // Assign the _members array
-        (group as any)._members = [
-            member1,
-            member2,
-        ];
-
-        const position: Vector3Like = { x: 7, y: 8, z: 9 };
-        group.SetPosition(position);
-
-        // Since members do not have onMove, there's nothing to assert
-        // If members have onMove as optional, you can spy on them to ensure they're not called
-    });
-
-    it('should handle an empty _members array without errors', () => {
-        // Assign an empty _members array
-        (group as any)._members = [];
-
-        const position: Vector3Like = { x: 10, y: 11, z: 12 };
-        expect(() => group.SetPosition(position)).not.toThrow();
-    });
-
-    it('should handle _members with mixed types correctly', () => {
-        // Create mixed members
-        const diveNode: DIVENode = {
-            isDIVENode: true,
-            onMove: jest.fn(),
-        } as unknown as DIVENode;
-
-        const member: DIVENode = {
-            // Define other properties/methods if necessary
-        } as unknown as DIVENode;
-
-        (group as any)._members = [
-            diveNode,
-            member,
-        ];
-
-        const position: Vector3Like = { x: 13, y: 14, z: 15 };
-        group.SetPosition(position);
-
-        // Ensure onMove is called only on diveNode
-        expect(diveNode.onMove).toHaveBeenCalled();
-    });
-});

package/src/helper/applyMixins/__test__/applyMixins.test.ts

@@ -1,30 +0,0 @@
-import { applyMixins } from '../applyMixins.ts';
-
-class Movable {
-    move() {}
-}
-
-class Selectable {
-    select() {}
-}
-
-describe('dive/helper/applyMixins', () => {
-    it('should apply mixins', () => {
-        class Product {
-            doProductThings() {}
-        }
-
-        interface Product extends Movable, Selectable {}
-
-        applyMixins(Product, [
-            Movable,
-            Selectable,
-        ]);
-
-        const instance = new Product();
-        expect(instance).toBeDefined();
-        expect(instance.move).toBeDefined();
-        expect(instance.select).toBeDefined();
-        expect(instance.doProductThings).toBeDefined();
-    });
-});

package/src/helper/applyMixins/applyMixins.ts

@@ -1,18 +0,0 @@
-/**
- * Merges two class prototypes to a new one.
- */
-
-export const applyMixins = (
-    derivedCtor: { prototype: object },
-    constructors: { prototype: object }[],
-): void => {
-    constructors.forEach((baseCtor) => {
-        Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
-            Object.defineProperty(
-                derivedCtor.prototype,
-                name,
-                Object.getOwnPropertyDescriptor(baseCtor.prototype, name)!,
-            );
-        });
-    });
-};

package/src/helper/findInterface/__test__/findInterface.test.ts

@@ -1,63 +0,0 @@
-import { Object3D } from 'three';
-import { findInterface } from '../findInterface.ts';
-
-describe('dive/helper/findInterface', () => {
-    it('should not find interface', () => {
-        expect(findInterface(null, 'isInterface')).toBe(undefined);
-
-        const obj = {} as unknown as Object3D;
-
-        expect(findInterface(obj, 'isInterface')).toBe(undefined);
-
-        // add traverse function
-        obj.traverseAncestors = jest.fn(
-            (callback: (object: Object3D) => any) => {
-                callback(obj);
-            },
-        );
-
-        expect(findInterface(obj, 'isInterface')).toBe(undefined);
-    });
-
-    it('should find interface in object', () => {
-        const obj = {
-            isInterface: true,
-            traverseAncestors: jest.fn(
-                (callback: (object: Object3D) => any) => {
-                    callback(obj);
-                },
-            ),
-        } as unknown as Object3D;
-
-        expect(findInterface(obj, 'isInterface')).toBe(obj);
-    });
-
-    it('should find interface in parent', () => {
-        const obj = {
-            traverseAncestors: jest.fn(
-                (callback: (object: Object3D) => any) => {
-                    callback(obj);
-                },
-            ),
-            parent: {
-                isInterface: true,
-
-                traverseAncestors: jest.fn(
-                    (callback: (object: Object3D) => any) => {
-                        callback(obj.parent!);
-                    },
-                ),
-
-                parent: {
-                    traverseAncestors: jest.fn(
-                        (callback: (object: Object3D) => any) => {
-                            callback(obj.parent!);
-                        },
-                    ),
-                },
-            },
-        } as unknown as Object3D;
-
-        expect(findInterface(obj, 'isInterface')).toBe(obj.parent);
-    });
-});

package/src/helper/findInterface/findInterface.ts

@@ -1,13 +0,0 @@
-import { implementsInterface } from '../isInterface/implementsInterface';
-import { type Object3D } from 'three';
-
-export function findInterface<T>(
-    object: Object3D | null | undefined,
-    discriminator: string,
-): (Object3D & T) | undefined {
-    if (!object) return undefined;
-
-    if (implementsInterface<T>(object, discriminator)) return object;
-
-    return findInterface<T>(object.parent, discriminator);
-}

package/src/helper/findSceneRecursive/__test__/findSceneRecursive.test.ts

@@ -1,40 +0,0 @@
-import type { Object3D } from 'three';
-import { findSceneRecursive } from '../findSceneRecursive.ts';
-
-describe('dive/helper/findSceneRecursive', () => {
-    it('should find itself if parent is not set', () => {
-        const obj = {} as Object3D;
-
-        const found = findSceneRecursive(obj);
-
-        expect(found).toStrictEqual(obj);
-    });
-
-    it('should find itself if it has no parent', () => {
-        const obj = {
-            parent: null,
-        } as Object3D;
-
-        const found = findSceneRecursive(obj);
-
-        expect(found).toStrictEqual(obj);
-    });
-
-    it('should find itself if it has no parent', () => {
-        const scene = {
-            parent: null,
-        } as Object3D;
-
-        const objparent = {
-            parent: scene,
-        } as Object3D;
-
-        const obj = {
-            parent: objparent,
-        } as Object3D;
-
-        const found = findSceneRecursive(obj);
-
-        expect(found).toStrictEqual(scene);
-    });
-});

package/src/helper/findSceneRecursive/findSceneRecursive.ts

@@ -1,16 +0,0 @@
-import { type Object3D } from 'three';
-import { type DIVEScene } from '../../scene/Scene';
-
-/**
- * Find the scene object of an object.
- *
- * @param object - The object to find the scene of.
- * @returns The scene object.
- */
-
-export const findSceneRecursive = (object: Object3D): DIVEScene => {
-    if (object.parent) {
-        return findSceneRecursive(object.parent);
-    }
-    return object as DIVEScene;
-};

package/src/helper/getObjectDelta/__test__/getObjectDelta.test.ts

@@ -1,186 +0,0 @@
-import { getObjectDelta } from '../getObjectDelta.ts';
-
-describe('dive/helper/getObjectDelta', () => {
-    // NO DELTAS
-    it('should not find any deltas with empty objects', () => {
-        const obj0 = {};
-        const obj1 = {};
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual({});
-    });
-
-    it('should not find any deltas with equal references', () => {
-        const obj0 = {
-            test0: 'test',
-            value0: 42,
-            array0: [
-                187,
-                6,
-                9,
-                42,
-            ],
-        };
-        const obj1 = obj0;
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual({});
-    });
-
-    it('should not find any deltas with equal objects', () => {
-        const obj0 = {
-            test0: 'test',
-            value0: 42,
-            array0: [
-                187,
-                6,
-                9,
-                42,
-            ],
-        };
-        const obj1 = { ...obj0 };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual({});
-    });
-
-    it('should not find any deltas with empty arrays', () => {
-        const obj0 = { array0: [] };
-        const obj1 = { array0: [] };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual({});
-    });
-
-    // DELTAS
-    it('should find deltas with incorrect types (case a)', () => {
-        const obj0 = 'test' as unknown as object;
-        const obj1 = { test: 0 };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual(obj1);
-    });
-
-    it('should find deltas with incorrect types (case b)', () => {
-        const obj0 = { test: 0 };
-        const obj1 = 'test' as unknown as object;
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual(obj1);
-    });
-
-    it('should find deltas with one empty object', () => {
-        const obj0 = {};
-        const obj1 = { test: 0 };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual(obj1);
-    });
-
-    it('should find deltas with different key lengths', () => {
-        const obj0 = { test: 0 };
-        const obj1 = { test: 0, test0: 0 };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual({ test0: 0 });
-    });
-
-    it('should find deltas with a type delta', () => {
-        const obj0 = { test: 'test' };
-        const obj1 = { test: 0 as unknown as string };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual(obj1);
-    });
-
-    it('should find deltas with a value delta', () => {
-        const obj0 = { test: 'test' };
-        const obj1 = { test: 'hello world!' };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual(obj1);
-    });
-
-    it('should find deltas with array value delta', () => {
-        const obj0 = {
-            array0: [
-                187,
-                6,
-                9,
-                42,
-            ],
-        };
-        const obj1 = {
-            array0: [
-                187,
-                6,
-                9,
-            ],
-        };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual(obj1);
-    });
-
-    it('should find deltas with array type difference', () => {
-        const obj0 = { array0: 'array0' };
-        const obj1 = {
-            array0: [
-                187,
-                6,
-                9,
-            ] as unknown as string,
-        };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual(obj1);
-    });
-
-    it('should find deltas with deltas in objects in array', () => {
-        const obj0 = { array0: [{ test: 0 }] };
-        const obj1 = { array0: [{ test: 1 }] };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual(obj1);
-    });
-
-    it('should find deltas with undefined value in objects in object', () => {
-        const obj0 = { object0: undefined as unknown as object };
-        const obj1 = { object0: { test: 1 } };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual(obj1);
-    });
-
-    it('should find deltas with wrong type in objects in object', () => {
-        const obj0 = { object0: 'test' };
-        const obj1 = { object0: { test: 1 } as unknown as string };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual(obj1);
-    });
-
-    it('should find deltas with empty value in objects in object', () => {
-        const obj0 = { object0: {} };
-        const obj1 = { object0: { test: 1 } };
-
-        const delta = getObjectDelta(obj0, obj1);
-
-        expect(delta).toStrictEqual(obj1);
-    });
-});

package/src/helper/getObjectDelta/getObjectDelta.ts

@@ -1,105 +0,0 @@
-/**
- * Find the difference between two objects.
- */
-
-export const getObjectDelta = <T extends object>(
-    a: T,
-    b: Partial<T>,
-): Partial<T> => {
-    // if a and b have no entries we have no delta
-    if (Object.keys(a).length === 0 && Object.keys(b).length === 0) {
-        return {};
-    }
-
-    // if a or b is not an object we have a delta
-    if (typeof a !== 'object' || typeof b !== 'object') {
-        return b;
-    }
-
-    let delta = {};
-
-    Object.keys(b).forEach((key) => {
-        // if key is not in a we have a delta
-        if (!Object.keys(a).includes(key)) {
-            delta = { ...delta, [key]: b[key as keyof object] };
-            return;
-        }
-
-        // assumption: b[key] is an array
-        if (Array.isArray(b[key as keyof object])) {
-            // if a[key] is not an array we have a delta
-            if (!Array.isArray(a[key as keyof object])) {
-                delta = { ...delta, [key]: b[key as keyof object] };
-                return;
-            }
-
-            // create arrays (for TS types to be correct)
-            const aArray = a[key as keyof object] as [];
-            const bArray = b[key as keyof object] as [];
-
-            // if both arrays are empty we have no delta
-            if (aArray.length === 0 && bArray.length === 0) {
-                delta = { ...delta };
-                return;
-            }
-
-            // if array length is different we have a delta
-            if (aArray.length !== bArray.length) {
-                delta = { ...delta, [key]: b[key as keyof object] };
-                return;
-            }
-
-            // create array for deltas
-            const arrayDeltas: [] = [];
-
-            bArray.forEach((entry, index) => {
-                // getObjectDelta in array
-                const inArrayDelta = getObjectDelta(
-                    aArray[index],
-                    bArray[index],
-                );
-
-                // if inArrayDelta has more then 0 entries we have a delta
-                if (Object.keys(inArrayDelta).length) {
-                    arrayDeltas.push(bArray[index]);
-                }
-            });
-
-            // if arrayDeltas has more than 0 entries we have a delta
-            if (Object.keys(arrayDeltas).length) {
-                delta = { ...delta, [key]: arrayDeltas };
-                return;
-            }
-
-            return;
-        }
-
-        // assumption: b[key] is an object
-        if (typeof b[key as keyof object] === 'object') {
-            // if a[key] is not an object we have a delta
-            if (typeof a[key as keyof object] !== 'object') {
-                delta = { ...delta, [key]: b[key as keyof object] };
-                return;
-            }
-
-            // recursive: find objectDelta in a and b
-            const objectDelta = getObjectDelta(
-                a[key as keyof object],
-                b[key as keyof object],
-            );
-
-            // if objectDelta has more than 0 entries we have a delta
-            if (Object.keys(objectDelta).length) {
-                delta = { ...delta, [key]: objectDelta };
-                return;
-            }
-        }
-
-        // if a[key] is not equal to b[key] we have a delta
-        if (a[key as keyof object] !== b[key as keyof object]) {
-            delta = { ...delta, [key]: b[key as keyof object] };
-        }
-    });
-
-    return delta;
-};