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

package/build/dive.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("./dive-C-5_QywE.cjs");exports.DIVE=e.DIVE;exports.DIVECommunication=e.DIVECommunication;exports.DIVEDefaultSettings=e.DIVEDefaultSettings;exports.DIVEMath=e.DIVEMath;exports.default=e.DIVE;
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("./dive-BTQZqHRt.cjs");exports.DIVE=e.DIVE;exports.DIVECommunication=e.DIVECommunication;exports.DIVEDefaultSettings=e.DIVEDefaultSettings;exports.DIVEMath=e.DIVEMath;exports.default=e.DIVE;
 //# sourceMappingURL=dive.cjs.map

package/build/dive.js

@@ -1,9 +1,9 @@
-import { k as s, l as D, j as e, m, k as o } from "./dive-BmDCwQRo.js";
+import { A as s, E as D, z as E, F as e, A as o } from "./dive-Dk0rFfvA.js";
 export {
   s as DIVE,
   D as DIVECommunication,
-  e as DIVEDefaultSettings,
-  m as DIVEMath,
+  E as DIVEDefaultSettings,
+  e as DIVEMath,
   o as default
 };
 //# sourceMappingURL=dive.js.map

package/build/src/ar/arquicklook/ARQuickLook.d.ts

@@ -1,8 +1,7 @@
 import { DIVEScene } from '../../scene/Scene';
 import { DIVEAROptions } from '../AR';
 export declare class DIVEARQuickLook {
-    private static _usdzExporter;
     static Launch(scene: DIVEScene, options?: DIVEAROptions): Promise<void>;
-    private static extractModels;
-    private static launchARFromNode;
+    private static launchARQuickLook;
+    private static findARQuickLookSrc;
 }

package/build/src/com/actions/media/generatemedia.d.ts

@@ -1,6 +1,6 @@
 import { Vector3Like } from 'three';
 export default interface GENERATE_MEDIA {
-    DESCRIPTION: 'Generates a screenshot, stores it in a Blob and writes the URL into the payload.';
+    DESCRIPTION: 'Generates a screenshot, stores it in a Blob and returns a Promise of a valid URI.';
     PAYLOAD: ({
         position: Vector3Like;
         target: Vector3Like;
@@ -9,7 +9,6 @@ export default interface GENERATE_MEDIA {
     }) & {
         width: number;
         height: number;
-        dataUri: string;
     };
-    RETURN: boolean;
+    RETURN: Promise<string>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@shopware-ag/dive",
-    "version": "1.18.5-beta.1",
+    "version": "1.18.5-beta.3",
     "description": "Shopware Spatial Framework",
     "type": "module",
     "main": "build/dive.cjs",

package/src/ar/arquicklook/ARQuickLook.ts

@@ -1,64 +1,93 @@
-import { Object3D } from 'three';
-import { DIVEUSDZExporter } from '../../exporters/usdz/USDZExporter';
 import { type DIVEScene } from '../../scene/Scene';
 import { type DIVEAROptions } from '../AR';
 
 export class DIVEARQuickLook {
-    private static _usdzExporter: DIVEUSDZExporter = new DIVEUSDZExporter();
-
     public static Launch(
         scene: DIVEScene,
         options?: DIVEAROptions,
     ): Promise<void> {
-        // create node to build usdz from
-        const quickLookScene = new Object3D();
-
-        // extract models from scene
-        quickLookScene.add(...this.extractModels(scene));
+        const url = this.findARQuickLookSrc(scene);
 
         // launch ARQuickLook
-        return this.launchARFromNode(quickLookScene, options);
-    }
-
-    private static extractModels(scene: DIVEScene): Object3D[] {
-        // extract models
-        return scene.Root.children;
+        return this.launchARQuickLook(url, options);
     }
 
-    private static launchARFromNode(
-        node: Object3D,
+    private static launchARQuickLook(
+        uri: string,
         options?: DIVEAROptions,
     ): Promise<void> {
-        // bundle USDZ
-        return this._usdzExporter
-            .parse(node, {
-                quickLookCompatible: true,
-                ar: {
-                    anchoring: { type: 'plane' },
-                    planeAnchoring: {
-                        alignment:
-                            options?.arPlacement === 'vertical'
-                                ? 'vertical'
-                                : 'horizontal',
-                    },
-                },
-            })
-            .then((usdz: Uint8Array) => {
-                // create blob
-                const blob = new Blob([usdz], { type: 'model/vnd.usdz+zip' });
-                let url = URL.createObjectURL(blob);
+        return new Promise((resolve) => {
+            if (options?.arScale === 'fixed') {
+                uri = uri.concat('#allowsContentScaling=0');
+            }
+
+            // launch ARQuickLook
+            const a = document.createElement('a');
+            a.innerHTML = '<picture></picture>'; // This is actually needed so the viewer opens instantly
+            a.rel = 'ar';
+            a.href = uri;
+            a.download = 'scene.usdz';
+            resolve();
+            a.click();
+        });
+    }
 
-                if (options?.arScale === 'fixed') {
-                    url = url.concat('#allowsContentScaling=0');
-                }
+    private static findARQuickLookSrc(scene: DIVEScene): string {
+        let uri: string | null = null;
 
-                // launch ARQuickLook
-                const a = document.createElement('a');
-                a.innerHTML = '<picture></picture>'; // This is actually needed so the viewer opens instantly
-                a.rel = 'ar';
-                a.href = url;
-                a.download = 'scene.usdz';
-                a.click();
-            });
+        scene.traverse((object) => {
+            if (uri) return;
+            if (object.userData.uri) {
+                uri = object.userData.uri;
+            }
+        });
+
+        if (!uri) {
+            throw new Error('No model found in scene');
+        }
+
+        return uri;
     }
+
+    // private static extractModels(scene: DIVEScene): Object3D[] {
+    //     // extract models
+    //     return scene.Root.children;
+    // }
+
+    // private static launchARFromNode(
+    //     node: Object3D,
+    //     options?: DIVEAROptions,
+    // ): Promise<void> {
+    //     // bundle USDZ
+    //     return this._usdzExporter
+    //         .parse(node, {
+    //             quickLookCompatible: true,
+    //             ar: {
+    //                 anchoring: { type: 'plane' },
+    //                 planeAnchoring: {
+    //                     alignment:
+    //                         options?.arPlacement === 'vertical'
+    //                             ? 'vertical'
+    //                             : 'horizontal',
+    //                 },
+    //             },
+    //         })
+    //         .then((usdz: Uint8Array) => {
+    //             // create blob
+    //             const blob = new Blob([usdz], { type: 'model/vnd.usdz+zip' });
+    //             let url = URL.createObjectURL(blob);
+
+    //             if (options?.arScale === 'fixed') {
+    //                 url = url.concat('#allowsContentScaling=0');
+    //             }
+
+    //             // launch ARQuickLook
+    //             const a = document.createElement('a');
+    //             a.innerHTML = '<picture></picture>'; // This is actually needed so the viewer opens instantly
+    //             a.rel = 'ar';
+    //             a.href = url;
+    //             a.download = 'scene.usdz';
+    //             a.click();
+    //         });
+    // }
 }

package/src/ar/arquicklook/__test__/ARQuickLook.test.ts

@@ -3,14 +3,20 @@ import { DIVEScene } from '../../../scene/Scene';
 import { DIVEAROptions } from '../../AR';
 import { DIVEARQuickLook } from '../ARQuickLook';
 
-jest.mock('../../../exporters/usdz/USDZExporter', () => {
+jest.mock('../../../scene/Scene', () => {
     return {
-        DIVEUSDZExporter: jest.fn().mockImplementation(() => {
-            return {
-                parse: jest.fn(() => {
-                    return Promise.resolve(new Uint8Array());
-                }),
+        DIVEScene: jest.fn(function () {
+            this.add = jest.fn();
+            this.children = [];
+            this.Root = {
+                children: [],
             };
+            this.traverse = jest.fn((callback) => {
+                this.Root.children.forEach((child: Object3D) => {
+                    callback(child);
+                });
+            });
+            return this;
         }),
     };
 });
@@ -26,10 +32,12 @@ describe('DIVEARQuickLook', () => {
         mockModels = [
             new Object3D(),
             new Object3D(),
+            new Object3D(),
         ];
-        mockScene = {
-            Root: new Object3D(),
-        } as DIVEScene;
+        mockModels[1].userData = {
+            uri: 'https://example.com',
+        };
+        mockScene = new DIVEScene();
         mockOptions = {
             arPlacement: 'horizontal',
             arScale: 'auto',
@@ -41,88 +49,45 @@ describe('DIVEARQuickLook', () => {
             expect(DIVEARQuickLook.Launch).toBeInstanceOf(Function);
         });
 
-        it('should return a promise', () => {
-            expect(
-                DIVEARQuickLook.Launch(mockScene, mockOptions),
-            ).toBeInstanceOf(Promise);
-        });
-
-        it('should not throw when called without options', () => {
-            const usdzParseSpy = jest.spyOn(
-                DIVEARQuickLook['_usdzExporter'],
-                'parse',
-            );
-
-            expect(
-                async () => await DIVEARQuickLook.Launch(mockScene),
-            ).not.toThrow();
-
-            expect(usdzParseSpy).toHaveBeenCalled();
-        });
-
-        it('should not throw when called with empty scene', () => {
-            const usdzParseSpy = jest.spyOn(
-                DIVEARQuickLook['_usdzExporter'],
-                'parse',
-            );
-
-            expect(
-                async () =>
-                    await DIVEARQuickLook.Launch(mockScene, mockOptions),
-            ).not.toThrow();
+        it('should not throw without options', () => {
+            mockScene.Root.children = mockModels;
 
-            expect(usdzParseSpy).toHaveBeenCalled();
+            expect(() => {
+                DIVEARQuickLook.Launch(mockScene);
+            }).not.toThrow();
         });
 
-        it('should not throw when called with filled scene', () => {
-            const usdzParseSpy = jest.spyOn(
-                DIVEARQuickLook['_usdzExporter'],
-                'parse',
-            );
-
+        it('should not throw with options', () => {
             mockScene.Root.children = mockModels;
 
-            expect(
-                async () =>
-                    await DIVEARQuickLook.Launch(mockScene, mockOptions),
-            ).not.toThrow();
-
-            expect(usdzParseSpy).toHaveBeenCalled();
+            expect(() => {
+                DIVEARQuickLook.Launch(mockScene, mockOptions);
+            }).not.toThrow();
         });
 
-        it('should pass options to exporter', async () => {
-            const usdzParseSpy = jest.spyOn(
-                DIVEARQuickLook['_usdzExporter'],
-                'parse',
-            );
-
-            mockOptions.arPlacement = 'vertical';
-            mockOptions.arScale = 'fixed';
+        it('should not throw with alternated options', () => {
+            mockScene.Root.children = mockModels;
 
-            await DIVEARQuickLook.Launch(mockScene, mockOptions);
+            mockOptions = {
+                arPlacement: 'vertical',
+                arScale: 'fixed',
+            } as DIVEAROptions;
 
-            expect(usdzParseSpy).toHaveBeenCalledWith(expect.any(Object3D), {
-                quickLookCompatible: true,
-                ar: {
-                    anchoring: { type: 'plane' },
-                    planeAnchoring: {
-                        alignment: 'vertical',
-                    },
-                },
-            });
+            expect(() => {
+                DIVEARQuickLook.Launch(mockScene, mockOptions);
+            }).not.toThrow();
         });
 
-        it('should reject when USDZExporter fails', async () => {
-            const usdzParseSpy = jest.spyOn(
-                DIVEARQuickLook['_usdzExporter'],
-                'parse',
-            );
-
-            usdzParseSpy.mockReturnValueOnce(Promise.reject());
+        it('should throw if no url is found', () => {
+            mockScene.Root.children = [
+                new Object3D(),
+                new Object3D(),
+                new Object3D(),
+            ];
 
-            await expect(
-                DIVEARQuickLook.Launch(mockScene, mockOptions),
-            ).rejects.toBeUndefined();
+            expect(() => {
+                DIVEARQuickLook.Launch(mockScene, mockOptions);
+            }).toThrow();
         });
     });
 });

package/src/ar/sceneviewer/__test__/SceneViewer.test.ts

@@ -21,18 +21,6 @@ jest.mock('../../../scene/Scene', () => {
     };
 });
 
-jest.mock('../../../exporters/usdz/USDZExporter', () => {
-    return {
-        DIVEUSDZExporter: jest.fn().mockImplementation(() => {
-            return {
-                parse: jest.fn(() => {
-                    return Promise.resolve(new Uint8Array());
-                }),
-            };
-        }),
-    };
-});
-
 URL.createObjectURL = jest.fn(() => 'blob:http://localhost:8080/');
 
 describe('DIVESceneViewer', () => {

package/src/com/Communication.ts

@@ -75,27 +75,51 @@ export class DIVECommunication {
     private toolbox: DIVEToolbox;
 
     private _mediaGenerator: DIVEMediaCreator | null;
-    private get mediaGenerator(): DIVEMediaCreator {
+    private get mediaGenerator(): Promise<DIVEMediaCreator> {
         if (!this._mediaGenerator) {
-            const DIVEMediaCreator = require('../mediacreator/MediaCreator.ts')
-                .DIVEMediaCreator as typeof import('../mediacreator/MediaCreator.ts').DIVEMediaCreator;
-            this._mediaGenerator = new DIVEMediaCreator(
-                this.renderer,
-                this.scene,
-                this.controller,
-            );
+            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 this._mediaGenerator;
+        return Promise.resolve(this._mediaGenerator);
     }
 
     private _io: DIVEIO | null;
-    private get io(): DIVEIO {
+    private get io(): Promise<DIVEIO> {
         if (!this._io) {
-            const DIVEIO = require('../io/IO.ts')
-                .DIVEIO as typeof import('../io/IO.ts').DIVEIO;
-            this._io = new DIVEIO(this.scene);
+            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 this._io;
+        return Promise.resolve(this._io);
     }
 
     private _ar: DIVEAR | null;
@@ -760,14 +784,14 @@ export class DIVECommunication {
             target = payload.target;
         }
 
-        payload.dataUri = this.mediaGenerator.GenerateMedia(
-            position,
-            target,
-            payload.width,
-            payload.height,
-        );
-
-        return true;
+        return this.mediaGenerator.then((module) => {
+            return module.GenerateMedia(
+                position,
+                target,
+                payload.width,
+                payload.height,
+            );
+        });
     }
 
     private setParent(
@@ -833,7 +857,13 @@ export class DIVECommunication {
     private exportScene(
         payload: Actions['EXPORT_SCENE']['PAYLOAD'],
     ): Actions['EXPORT_SCENE']['RETURN'] {
-        return this.io.Export(payload.type);
+        return new Promise<string | null>((resolve, reject) => {
+            this.io
+                .then((ioModule) => {
+                    resolve(ioModule.Export(payload.type));
+                })
+                .catch(reject);
+        });
     }
 }
 

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

@@ -842,7 +842,14 @@ describe('dive/communication/DIVECommunication', () => {
         expect(success1).toBe(true);
     });
 
-    it('should perform action GENERATE_MEDIA', () => {
+    it('should perform action GENERATE_MEDIA', async () => {
+        const blobUri = 'blob:http://localhost:3000/1234';
+        const mediaGeneratorModule = await testCom['mediaGenerator'];
+
+        jest.spyOn(mediaGeneratorModule, 'GenerateMedia').mockReturnValue(
+            blobUri,
+        );
+
         const mock1 = {
             entityType: 'pov',
             id: 'test1',
@@ -851,22 +858,22 @@ describe('dive/communication/DIVECommunication', () => {
         } as COMPov;
         testCom.PerformAction('ADD_OBJECT', mock1);
 
-        const success0 = testCom.PerformAction('GENERATE_MEDIA', {
+        const success0 = await testCom.PerformAction('GENERATE_MEDIA', {
             id: 'test1',
             width: 800,
             height: 600,
-            dataUri: '',
         });
-        expect(success0).toBe(true);
+        expect(success0).toBe(blobUri);
 
-        const success1 = testCom.PerformAction('GENERATE_MEDIA', {
+        const success1 = await testCom.PerformAction('GENERATE_MEDIA', {
             position: { x: 0, y: 0, z: 0 },
             target: { x: 0, y: 0, z: 0 },
             width: 800,
             height: 600,
-            dataUri: '',
         });
-        expect(success1).toBe(true);
+        expect(success1).toBe(blobUri);
+
+        jest.restoreAllMocks();
     });
 
     it('should perform action SET_PARENT', () => {
@@ -955,8 +962,9 @@ describe('dive/communication/DIVECommunication', () => {
 
     it('should perform action EXPORT_SCENE', async () => {
         const url = 'https://example.com';
+        const ioModule = await testCom['io'];
 
-        jest.spyOn(testCom['io'], 'Export').mockResolvedValueOnce(url);
+        jest.spyOn(ioModule, 'Export').mockResolvedValueOnce(url);
 
         const result = await testCom.PerformAction('EXPORT_SCENE', {
             type: 'glb',

package/src/com/actions/media/generatemedia.ts

@@ -1,7 +1,7 @@
 import { Vector3Like } from 'three';
 
 export default interface GENERATE_MEDIA {
-    DESCRIPTION: 'Generates a screenshot, stores it in a Blob and writes the URL into the payload.';
+    DESCRIPTION: 'Generates a screenshot, stores it in a Blob and returns a Promise of a valid URI.';
     PAYLOAD: (
         | {
               position: Vector3Like;
@@ -13,7 +13,6 @@ export default interface GENERATE_MEDIA {
     ) & {
         width: number; // image width in pixels
         height: number; // image height in pixels
-        dataUri: string;
     };
-    RETURN: boolean;
+    RETURN: Promise<string>;
 }