@heliguy-xyz/splat-viewer 1.0.0-rc.2 → 1.0.0-rc.3

package/dist/web-component/splat-viewer.js

@@ -140833,33 +140833,93 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        if (!this.app)
 	            return;
 	        const canvas = this.app.graphicsDevice.canvas;
-	        // Set the canvas resolution to match the display size with device pixel ratio
+	        // Ensure canvas and its parent fill available space by default (non-destructive)
+	        if (!canvas.style.display)
+	            canvas.style.display = 'block';
+	        if (!canvas.style.width)
+	            canvas.style.width = '100%';
+	        if (!canvas.style.height)
+	            canvas.style.height = '100%';
+	        if (canvas.parentElement) {
+	            const ps = canvas.parentElement.style;
+	            if (!ps.width)
+	                ps.width = '100%';
+	            if (!ps.height)
+	                ps.height = '100%';
+	        }
+	        // Helper: apply resolution and notify dependents
+	        const applyResolution = (width, height) => {
+	            if (canvas.width === width && canvas.height === height)
+	                return;
+	            canvas.width = width;
+	            canvas.height = height;
+	            this.app.resizeCanvas(width, height);
+	            if (this._orbit &&
+	                this._orbit.navigationCube &&
+	                typeof this._orbit.navigationCube.onCanvasResize === 'function') {
+	                this._orbit.navigationCube.onCanvasResize();
+	            }
+	        };
+	        // Fallback: compute from CSS box * devicePixelRatio
 	        const updateResolution = () => {
 	            const rect = canvas.getBoundingClientRect();
 	            const pixelRatio = window.devicePixelRatio || 1;
-	            // Set canvas internal resolution to match display size * pixel ratio
 	            const width = Math.floor(rect.width * pixelRatio);
 	            const height = Math.floor(rect.height * pixelRatio);
-	            if (canvas.width !== width || canvas.height !== height) {
-	                canvas.width = width;
-	                canvas.height = height;
-	                // Update PlayCanvas app resolution
-	                this.app.resizeCanvas(width, height);
-	                // Notify navigation cube about canvas resize
-	                if (this._orbit &&
-	                    this._orbit.navigationCube &&
-	                    typeof this._orbit.navigationCube.onCanvasResize ===
-	                        'function') {
-	                    this._orbit.navigationCube.onCanvasResize();
+	            applyResolution(width, height);
+	        };
+	        // Prefer ResizeObserver entry data (devicePixelContentBoxSize when available)
+	        const updateFromEntry = (entry) => {
+	            let width = null;
+	            let height = null;
+	            const dpcb = entry.devicePixelContentBoxSize;
+	            if (dpcb && dpcb.length > 0) {
+	                width = Math.ceil(dpcb[0].inlineSize);
+	                height = Math.ceil(dpcb[0].blockSize);
+	            }
+	            else {
+	                const cbs = entry.contentBoxSize;
+	                if (cbs && cbs.length > 0) {
+	                    const pixelRatio = window.devicePixelRatio || 1;
+	                    width = Math.ceil(cbs[0].inlineSize * pixelRatio);
+	                    height = Math.ceil(cbs[0].blockSize * pixelRatio);
 	                }
 	            }
+	            if (width !== null && height !== null) {
+	                applyResolution(width, height);
+	            }
+	            else {
+	                updateResolution();
+	            }
 	        };
 	        // Initial resolution setup
 	        updateResolution();
 	        // Set up resize observer for automatic resolution updates
 	        if (window.ResizeObserver) {
-	            this._resizeObserver = new ResizeObserver(() => {
-	                updateResolution();
+	            this._resizeObserver = new ResizeObserver((entries) => {
+	                if (!entries || entries.length === 0) {
+	                    updateResolution();
+	                    return;
+	                }
+	                const canvasEntry = entries.find(e => e.target === canvas);
+	                if (canvasEntry) {
+	                    updateFromEntry(canvasEntry);
+	                }
+	                else {
+	                    // Fall back to the first entry if canvas wasn't explicitly included
+	                    if (entries.length > 0) {
+	                        const firstEntry = entries[0];
+	                        if (firstEntry) {
+	                            updateFromEntry(firstEntry);
+	                        }
+	                        else {
+	                            updateResolution();
+	                        }
+	                    }
+	                    else {
+	                        updateResolution();
+	                    }
+	                }
 	            });
 	            // Observe both the canvas and its parent container for resize events
 	            this._resizeObserver.observe(canvas);
@@ -140867,11 +140927,11 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	                this._resizeObserver.observe(canvas.parentElement);
 	            }
 	        }
-	        else {
-	            // Fallback for browsers without ResizeObserver
-	            window.addEventListener('resize', updateResolution);
-	            this._resizeHandler = updateResolution;
-	        }
+	        // Additionally listen to window resize to handle viewport changes
+	        // (e.g., when resizing dev tools). This mirrors superSplat behavior
+	        // and ensures the canvas always matches the available space.
+	        window.addEventListener('resize', updateResolution);
+	        this._resizeHandler = updateResolution;
 	    }
 	}