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

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,70 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/ban-types */
-// A generic constructor type.
-type Constructor<T = {}> = new (...args: any[]) => T;
-
-// Converts a union of types to an intersection of types.
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
-    k: infer I,
-) => void
-    ? I
-    : never;
-
-// Merges the instance types of the base class and all mixin classes.
-type MixedInstance<
-    T extends Constructor,
-    K extends readonly Constructor[],
-> = InstanceType<T> & UnionToIntersection<InstanceType<K[number]>>;
-
-// Recursively flatten the constructor parameter lists for a tuple of constructors.
-type FlattenConstructorParams<T extends readonly Constructor[]> =
-    T extends readonly [infer First, ...infer Rest]
-        ? First extends Constructor
-            ? Rest extends readonly Constructor[]
-                ? [
-                      ...ConstructorParameters<First>,
-                      ...FlattenConstructorParams<Rest>,
-                  ]
-                : ConstructorParameters<First>
-            : []
-        : [];
-
-// Constructs the mixed constructor type.
-// It accepts the parameters of T followed by all the parameters of K and
-// produces an instance that is the intersection of the instance types.
-type MixedConstructor<
-    T extends Constructor,
-    K extends readonly Constructor[],
-> = new (
-    ...args: [...ConstructorParameters<T>, ...FlattenConstructorParams<K>]
-) => MixedInstance<T, K>;
-
-/**
- * Applies mixins to a base class.
- *
- * @param derivedCtor Base class constructor
- * @param constructors Additional constructors that get mixed into the base class
- * @returns A mixed constructor with the instance type of the base class and all mixin classes
- * @example
- * ```
- * const SelectableMovableObject3D = applyMixins(Object3D, [DIVESelectable, DIVEMovable]);
- * const instance = new SelectableMovableObject3D();
- * instance.onMove();
- * instance.onSelect();
- * ```
- */
-export function applyMixins<
-    T extends Constructor,
-    K extends readonly Constructor[],
->(derivedCtor: T, constructors: K): MixedConstructor<T, K> {
-    constructors.forEach((baseCtor) => {
-        Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
-            Object.defineProperty(
-                derivedCtor.prototype,
-                name,
-                Object.getOwnPropertyDescriptor(baseCtor.prototype, name)!,
-            );
-        });
-    });
-    return derivedCtor as unknown as MixedConstructor<T, K>;
-}

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