@shopware-ag/dive 1.18.5-beta.3 → 1.18.5

package/build/src/com/Communication.d.ts

@@ -34,16 +34,13 @@ export declare class DIVECommunication {
     private controller;
     private toolbox;
     private _mediaGenerator;
-    private get mediaGenerator();
     private _io;
-    private get io();
     private _ar;
-    private get ar();
     private registered;
     private listeners;
     constructor(renderer: DIVERenderer, scene: DIVEScene, controls: DIVEOrbitControls, toolbox: DIVEToolbox);
     DestroyInstance(): boolean;
-    PerformAction<Action extends keyof Actions>(action: Action, payload: Actions[Action]['PAYLOAD']): Actions[Action]['RETURN'];
+    PerformAction<Action extends keyof Actions>(action: Action, payload?: Actions[Action]['PAYLOAD']): Actions[Action]['RETURN'];
     Subscribe<Action extends keyof Actions>(type: Action, listener: EventListener<Action>): Unsubscribe;
     private dispatch;
     private getAllSceneData;

package/build/src/module/Module.d.ts

@@ -0,0 +1,8 @@
+export declare class DIVEModule<T> {
+    private _path;
+    private _ctor;
+    constructor(_path: string, _ctor: string);
+    private _promise;
+    private _instance;
+    get(): Promise<T>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@shopware-ag/dive",
-    "version": "1.18.5-beta.3",
+    "version": "1.18.5",
     "description": "Shopware Spatial Framework",
     "type": "module",
     "main": "build/dive.cjs",
@@ -51,7 +51,7 @@
         "ts-jest": "^29.1.2",
         "ts-node": "^10.9.2",
         "tsc": "^2.0.4",
-        "typescript": "^5.4.5",
+        "typescript": "^5.8.2",
         "typescript-eslint": "^7.7.1",
         "vite": "^6.2.1",
         "vite-plugin-dts": "^4.5.3"

package/src/com/Communication.ts

@@ -2,6 +2,7 @@ import { Actions } from './actions/index.ts';
 import { generateUUID } from 'three/src/math/MathUtils';
 import { isSelectTool } from '../toolbox/select/SelectTool.ts';
 import { merge } from 'lodash';
+import { DIVEModule } from '../module/Module.ts';
 
 // type imports
 import { type Color, type MeshStandardMaterial } from 'three';
@@ -74,80 +75,13 @@ export class DIVECommunication {
     private controller: DIVEOrbitControls;
     private toolbox: DIVEToolbox;
 
-    private _mediaGenerator: DIVEMediaCreator | null;
-    private get mediaGenerator(): Promise<DIVEMediaCreator> {
-        if (!this._mediaGenerator) {
-            return new Promise((resolve, reject) => {
-                import('../mediacreator/MediaCreator.ts')
-                    .then((module) => {
-                        const DIVEMediaCreator = module.DIVEMediaCreator;
-                        this._mediaGenerator = new DIVEMediaCreator(
-                            this.renderer,
-                            this.scene,
-                            this.controller,
-                        );
-                        resolve(this._mediaGenerator);
-                    })
-                    .catch((error) => {
-                        console.error(
-                            'DIVE: Error while lazy-loading IO module:',
-                            error,
-                        );
-                        reject(error);
-                    });
-            });
-        }
-        return Promise.resolve(this._mediaGenerator);
-    }
-
-    private _io: DIVEIO | null;
-    private get io(): Promise<DIVEIO> {
-        if (!this._io) {
-            return new Promise((resolve, reject) => {
-                import('../io/IO.ts')
-                    .then((module) => {
-                        const DIVEIO = module.DIVEIO;
-                        this._io = new DIVEIO(this.scene);
-                        resolve(this._io);
-                    })
-                    .catch((error) => {
-                        console.error(
-                            'DIVE: Error while lazy-loading IO module:',
-                            error,
-                        );
-                        reject(error);
-                    });
-            });
-        }
-        return Promise.resolve(this._io);
-    }
-
-    private _ar: DIVEAR | null;
-    private get ar(): Promise<DIVEAR> {
-        if (!this._ar) {
-            return new Promise((resolve, reject) => {
-                import('../ar/AR.ts')
-                    .then((module) => {
-                        const DIVEAR = module.DIVEAR;
-                        this._ar = new DIVEAR(
-                            this.renderer,
-                            this.scene,
-                            this.controller,
-                        );
-                        resolve(this._ar);
-                    })
-                    .catch((error) => {
-                        console.error(
-                            'DIVE: Error while lazy-loading AR module:',
-                            error,
-                        );
-                        reject(error);
-                    });
-            });
-        }
+    private _mediaGenerator: DIVEModule<DIVEMediaCreator> = new DIVEModule(
+        '../mediacreator/MediaCreator.ts',
+        'DIVEMediaCreator',
+    );
+    private _io: DIVEModule<DIVEIO> = new DIVEModule('../io/IO.ts', 'DIVEIO');
 
-        return Promise.resolve(this._ar);
-    }
+    private _ar: DIVEModule<DIVEAR> = new DIVEModule('../ar/AR.ts', 'DIVEAR');
 
     private registered: Map<string, COMEntity> = new Map();
 
@@ -166,9 +100,6 @@ export class DIVECommunication {
         this.scene = scene;
         this.controller = controls;
         this.toolbox = toolbox;
-        this._mediaGenerator = null;
-        this._io = null;
-        this._ar = null;
 
         DIVECommunication.__instances.push(this);
     }
@@ -184,7 +115,7 @@ export class DIVECommunication {
 
     public PerformAction<Action extends keyof Actions>(
         action: Action,
-        payload: Actions[Action]['PAYLOAD'],
+        payload?: Actions[Action]['PAYLOAD'],
     ): Actions[Action]['RETURN'] {
         let returnValue: Actions[Action]['RETURN'] = false;
 
@@ -353,10 +284,11 @@ export class DIVECommunication {
             }
             case 'LAUNCH_AR': {
                 returnValue = new Promise<void>((resolve, reject) => {
-                    this.ar
-                        .then((arModule) => {
+                    this._ar
+                        .get()
+                        .then((ar) => {
                             resolve(
-                                arModule.Launch(
+                                ar.Launch(
                                     payload as Actions['LAUNCH_AR']['PAYLOAD'],
                                 ),
                             );
@@ -784,7 +716,7 @@ export class DIVECommunication {
             target = payload.target;
         }
 
-        return this.mediaGenerator.then((module) => {
+        return this._mediaGenerator.get().then((module) => {
             return module.GenerateMedia(
                 position,
                 target,
@@ -858,9 +790,10 @@ export class DIVECommunication {
         payload: Actions['EXPORT_SCENE']['PAYLOAD'],
     ): Actions['EXPORT_SCENE']['RETURN'] {
         return new Promise<string | null>((resolve, reject) => {
-            this.io
-                .then((ioModule) => {
-                    resolve(ioModule.Export(payload.type));
+            this._io
+                .get()
+                .then((io) => {
+                    resolve(io.Export(payload.type));
                 })
                 .catch(reject);
         });

package/src/com/__test__/Communication.test.ts

@@ -32,36 +32,47 @@ import {
     type COMLight,
     type COMModel,
     type COMPov,
-    type COMPrimitive,
 } from '../types';
 import { type DIVESceneObject } from '../../types';
 
-jest.mock('../../mediacreator/MediaCreator', () => {
+const mockModule: Record<string, any> = {
+    get: jest.fn().mockReturnValue(Promise.resolve({})),
+};
+jest.mock('../../module/Module', () => {
     return {
-        DIVEMediaCreator: jest.fn(function () {
-            this.GenerateMedia = jest.fn();
+        DIVEModule: jest.fn().mockImplementation(() => {
+            return mockModule;
+        }),
+    };
+});
 
-            return this;
+jest.mock('../../mediacreator/MediaCreator', () => {
+    return {
+        DIVEMediaCreator: jest.fn().mockImplementation(() => {
+            return {
+                GenerateMedia: jest.fn(),
+            };
         }),
     };
 });
 
 jest.mock('../../io/IO', () => {
     return {
-        DIVEIO: jest.fn(function () {
-            this.Import = jest.fn();
-            this.Export = jest.fn();
-            return this;
+        DIVEIO: jest.fn().mockImplementation(() => {
+            return {
+                Import: jest.fn(),
+                Export: jest.fn(),
+            };
         }),
     };
 });
 
 jest.mock('../../ar/AR', () => {
     return {
-        DIVEAR: jest.fn(function () {
-            this.Launch = jest.fn();
-
-            return this;
+        DIVEAR: jest.fn().mockImplementation(() => {
+            return {
+                Launch: jest.fn(),
+            };
         }),
     };
 });
@@ -194,12 +205,14 @@ const mockToolBox = {
     }),
     SetGizmoMode: jest.fn(),
     SetGizmoVisibility: jest.fn(),
+    SetGizmoScaleLinked: jest.fn(),
 } as unknown as DIVEToolbox;
 
 let testCom: DIVECommunication;
 
 describe('dive/communication/DIVECommunication', () => {
     beforeEach(() => {
+        jest.clearAllMocks();
         testCom = new DIVECommunication(
             mockRenderer,
             mockScene,
@@ -797,6 +810,11 @@ describe('dive/communication/DIVECommunication', () => {
         expect(visibility).toBe(false);
     });
 
+    it('should perform action SET_GIZMO_SCALE_LINKED', () => {
+        const success = testCom.PerformAction('SET_GIZMO_SCALE_LINKED', true);
+        expect(success).toBe(true);
+    });
+
     it('should perform action USE_TOOL', () => {
         let success = testCom.PerformAction('USE_TOOL', { tool: 'select' });
         expect(success).toBe(true);
@@ -844,7 +862,10 @@ describe('dive/communication/DIVECommunication', () => {
 
     it('should perform action GENERATE_MEDIA', async () => {
         const blobUri = 'blob:http://localhost:3000/1234';
-        const mediaGeneratorModule = await testCom['mediaGenerator'];
+        jest.spyOn(mockModule, 'get').mockResolvedValue({
+            GenerateMedia: jest.fn(),
+        });
+        const mediaGeneratorModule = await testCom['_mediaGenerator'].get();
 
         jest.spyOn(mediaGeneratorModule, 'GenerateMedia').mockReturnValue(
             blobUri,
@@ -962,7 +983,10 @@ describe('dive/communication/DIVECommunication', () => {
 
     it('should perform action EXPORT_SCENE', async () => {
         const url = 'https://example.com';
-        const ioModule = await testCom['io'];
+        jest.spyOn(mockModule, 'get').mockResolvedValue({
+            Export: jest.fn(),
+        });
+        const ioModule = await testCom['_io'].get();
 
         jest.spyOn(ioModule, 'Export').mockResolvedValueOnce(url);
 
@@ -973,7 +997,10 @@ describe('dive/communication/DIVECommunication', () => {
     });
 
     it('should perform action LAUNCH_AR', async () => {
-        const arModule = await testCom['ar'];
+        jest.spyOn(mockModule, 'get').mockResolvedValue({
+            Launch: jest.fn(),
+        });
+        const arModule = await testCom['_ar'].get();
         const arLaunchSpy = jest
             .spyOn(arModule, 'Launch')
             .mockResolvedValueOnce();

package/src/module/Module.ts

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,54 @@
+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);
+    });
+});