@webspatial/core-sdk 1.5.0 → 1.6.1

package/src/scene-polyfill.manifest.test.ts

@@ -0,0 +1,402 @@
+import { describe, it, expect, vi } from 'vitest'
+
+vi.mock('./JSBCommand', () => {
+  return {
+    createSpatialSceneCommand: vi.fn().mockImplementation(() => ({
+      executeSync: vi.fn().mockReturnValue({
+        data: { id: 'scene-1', windowProxy: {} },
+      }),
+    })),
+    FocusScene: vi.fn().mockImplementation(() => ({
+      execute: vi.fn().mockResolvedValue(undefined),
+    })),
+  }
+})
+
+function addDataManifest(manifest: any) {
+  const link = document.createElement('link')
+  link.rel = 'manifest'
+  const json = JSON.stringify(manifest)
+  link.href = 'data:application/manifest+json,' + encodeURIComponent(json)
+  document.head.appendChild(link)
+  return () => {
+    document.head.removeChild(link)
+  }
+}
+
+async function waitTick() {
+  await Promise.resolve()
+  await new Promise(r => setTimeout(r, 0))
+}
+
+describe('setupManifest applies overrides to xr_window_defaults / xr_volume_defaults', () => {
+  it('applies window overrides without affecting volume defaults', async () => {
+    vi.resetModules()
+    const cleanup = addDataManifest({
+      xr_spatial_scene: {
+        defaultSize: { width: '200px', height: '300px' },
+        resizability: { minWidth: '300px', minHeight: '400px' },
+        worldScaling: 'dynamic',
+        worldAlignment: 'gravityAligned',
+        baseplateVisibility: 'visible',
+        overrides: {
+          window_scene: {
+            defaultSize: { width: '1000px' },
+            resizability: { minWidth: '500px', maxWidth: '1200px' },
+            worldAlignment: 'automatic',
+          },
+        },
+      },
+    })
+    const { hijackWindowOpen, initScene } = await import('./scene-polyfill')
+    hijackWindowOpen(window)
+    await waitTick()
+
+    let winDefaults: any
+    initScene(
+      'w',
+      pre => {
+        winDefaults = pre
+        return pre
+      },
+      { type: 'window' },
+    )
+
+    let volDefaults: any
+    initScene(
+      'v',
+      pre => {
+        volDefaults = pre
+        return pre
+      },
+      { type: 'volume' },
+    )
+
+    // window uses overrides + formatted to px
+    expect(winDefaults).toEqual(
+      expect.objectContaining({
+        defaultSize: { width: '1000px', height: '300px' },
+        resizability: expect.objectContaining({
+          minWidth: '500px',
+          minHeight: '400px',
+          maxWidth: '1200px',
+        }),
+        worldAlignment: 'automatic',
+        worldScaling: 'dynamic',
+        baseplateVisibility: 'visible',
+      }),
+    )
+
+    // volume remains from top-level only (no volume override) and formats:
+    // - pre passed to initScene is the raw manifest values (unformatted)
+    expect(volDefaults).toEqual(
+      expect.objectContaining({
+        defaultSize: {
+          width: '200px',
+          height: '300px',
+          // depth may be omitted in manifest; defaults keep only provided keys
+        },
+        resizability: expect.objectContaining({
+          minWidth: '300px',
+          minHeight: '400px',
+        }),
+        worldAlignment: 'gravityAligned',
+        worldScaling: 'dynamic',
+        baseplateVisibility: 'visible',
+      }),
+    )
+
+    cleanup()
+  })
+
+  it('applies volume overrides without affecting window defaults', async () => {
+    vi.resetModules()
+    const cleanup = addDataManifest({
+      xr_spatial_scene: {
+        defaultSize: { width: '120px', height: '240px' },
+        resizability: { minWidth: '200px', minHeight: '300px' },
+        overrides: {
+          volume_scene: {
+            defaultSize: { width: '2m', height: '2m', depth: '2m' },
+            resizability: { minWidth: '1m' },
+            baseplateVisibility: 'automatic',
+          },
+        },
+      },
+    })
+    const { hijackWindowOpen, initScene } = await import('./scene-polyfill')
+    hijackWindowOpen(window)
+    await waitTick()
+
+    let volDefaults: any
+    initScene(
+      'v',
+      pre => {
+        volDefaults = pre
+        return pre
+      },
+      { type: 'volume' },
+    )
+    let winDefaults: any
+    initScene(
+      'w',
+      pre => {
+        winDefaults = pre
+        return pre
+      },
+      { type: 'window' },
+    )
+
+    // volume uses overrides + formatting (m for defaultSize, px for resizability)
+    expect(volDefaults).toEqual(
+      expect.objectContaining({
+        defaultSize: { width: '2m', height: '2m', depth: '2m' },
+        resizability: expect.objectContaining({
+          minWidth: '1m',
+        }),
+        baseplateVisibility: 'automatic',
+      }),
+    )
+
+    // window remains from top-level only (no window override)
+    expect(winDefaults).toEqual(
+      expect.objectContaining({
+        defaultSize: { width: '120px', height: '240px' },
+        resizability: expect.objectContaining({
+          minWidth: '200px',
+          minHeight: '300px',
+        }),
+      }),
+    )
+
+    cleanup()
+  })
+
+  it('applies provided mixed-case defaults and empty volume override; volume pre is formatted as expected', async () => {
+    vi.resetModules()
+    const cleanup = addDataManifest({
+      xr_spatial_scene: {
+        default_size: {
+          width: '1024px',
+          height: '1024px',
+          depth: '55px',
+        },
+        resizability: {
+          minWidth: '1024px',
+          minHeight: '1024px',
+          maxWidth: '2000px',
+          maxHeight: '2000px',
+        },
+        worldScaling: 'automatic',
+        worldAlignment: 'automatic',
+        baseplateVisibility: 'visible',
+        overrides: {
+          window_scene: {
+            default_size: {
+              width: '500px',
+              height: '500px',
+              depth: '55px',
+            },
+            resizability: {
+              minWidth: '500px',
+              minHeight: '500px',
+              maxWidth: '1000px',
+              maxHeight: '1000px',
+            },
+          },
+          volume_scene: {},
+        },
+      },
+    })
+    const { hijackWindowOpen, initScene } = await import('./scene-polyfill')
+    hijackWindowOpen(window)
+    await waitTick()
+
+    const pxToM = (px: number) => px / 1360
+
+    let volDefaults: any
+    initScene(
+      'sa',
+      pre => {
+        volDefaults = pre
+        return { ...pre }
+      },
+      { type: 'volume' },
+    )
+
+    expect(volDefaults).toEqual(
+      expect.objectContaining({
+        defaultSize: {
+          width: '1024px',
+          height: '1024px',
+          depth: '55px',
+        },
+        resizability: expect.objectContaining({
+          minWidth: '1024px',
+          minHeight: '1024px',
+          maxWidth: '2000px',
+          maxHeight: '2000px',
+        }),
+        worldScaling: 'automatic',
+        worldAlignment: 'automatic',
+        baseplateVisibility: 'visible',
+      }),
+    )
+
+    // Snapshot current 'sa' internal config before cleanup
+    const { __getSceneConfigSnapshotForTest } = await import('./scene-polyfill')
+    const snap = __getSceneConfigSnapshotForTest('sa')
+    expect(snap).toEqual(
+      expect.objectContaining({
+        type: 'volume',
+        defaultSize: {
+          width: pxToM(1024),
+          height: pxToM(1024),
+          depth: pxToM(55),
+        },
+        resizability: expect.objectContaining({
+          minWidth: 1024,
+          minHeight: 1024,
+          maxWidth: 2000,
+          maxHeight: 2000,
+        }),
+      }),
+    )
+
+    cleanup()
+  })
+})
+
+describe('manifest error paths and empty configs', () => {
+  function addInvalidDataManifest() {
+    const link = document.createElement('link')
+    link.rel = 'manifest'
+    // Invalid JSON payload to force parse failure in getPWAManifest
+    link.href = 'data:application/manifest+json,INVALID_JSON'
+    document.head.appendChild(link)
+    return () => {
+      document.head.removeChild(link)
+    }
+  }
+
+  it('falls back to built-in defaults when no manifest link is present', async () => {
+    vi.resetModules()
+    const { hijackWindowOpen, initScene } = await import('./scene-polyfill')
+    hijackWindowOpen(window)
+    await waitTick()
+
+    let winPre: any
+    initScene(
+      'no-manifest-win',
+      pre => {
+        winPre = pre
+        return pre
+      },
+      { type: 'window' },
+    )
+    let volPre: any
+    initScene(
+      'no-manifest-vol',
+      pre => {
+        volPre = pre
+        return pre
+      },
+      { type: 'volume' },
+    )
+
+    // Window defaults: numbers in px domain for width/height
+    expect(winPre).toEqual(
+      expect.objectContaining({
+        defaultSize: { width: 1280, height: 720 },
+      }),
+    )
+    // Volume defaults: strings in meters for width/height/depth
+    expect(volPre).toEqual(
+      expect.objectContaining({
+        defaultSize: { width: '0.94m', height: '0.94m', depth: '0.94m' },
+      }),
+    )
+  })
+
+  it('falls back to built-in defaults when manifest parsing fails', async () => {
+    vi.resetModules()
+    const cleanup = addInvalidDataManifest()
+    const { hijackWindowOpen, initScene } = await import('./scene-polyfill')
+    hijackWindowOpen(window)
+    await waitTick()
+
+    let winPre: any
+    initScene(
+      'bad-manifest-win',
+      pre => {
+        winPre = pre
+        return pre
+      },
+      { type: 'window' },
+    )
+    let volPre: any
+    initScene(
+      'bad-manifest-vol',
+      pre => {
+        volPre = pre
+        return pre
+      },
+      { type: 'volume' },
+    )
+
+    expect(winPre).toEqual(
+      expect.objectContaining({
+        defaultSize: { width: 1280, height: 720 },
+      }),
+    )
+    expect(volPre).toEqual(
+      expect.objectContaining({
+        defaultSize: { width: '0.94m', height: '0.94m', depth: '0.94m' },
+      }),
+    )
+
+    cleanup()
+  })
+
+  it('ignores empty xr_spatial_scene object and preserves built-in defaults', async () => {
+    vi.resetModules()
+    const cleanup = addDataManifest({
+      xr_spatial_scene: {},
+    })
+    const { hijackWindowOpen, initScene } = await import('./scene-polyfill')
+    hijackWindowOpen(window)
+    await waitTick()
+
+    let winPre: any
+    initScene(
+      'empty-xr-win',
+      pre => {
+        winPre = pre
+        return pre
+      },
+      { type: 'window' },
+    )
+    let volPre: any
+    initScene(
+      'empty-xr-vol',
+      pre => {
+        volPre = pre
+        return pre
+      },
+      { type: 'volume' },
+    )
+
+    expect(winPre).toEqual(
+      expect.objectContaining({
+        defaultSize: { width: 1280, height: 720 },
+      }),
+    )
+    expect(volPre).toEqual(
+      expect.objectContaining({
+        defaultSize: { width: '0.94m', height: '0.94m', depth: '0.94m' },
+      }),
+    )
+
+    cleanup()
+  })
+})

package/src/scene-polyfill.test.ts

@@ -1,6 +1,13 @@
 import { describe, expect, test, vi, beforeEach, afterEach, it } from 'vitest'
-import { formatSceneConfig, initScene, injectSceneHook } from './scene-polyfill'
+import {
+  formatSceneConfig,
+  initScene,
+  injectSceneHook,
+  __getSceneConfigSnapshotForTest,
+  hijackWindowATag,
+} from './scene-polyfill'
 import { SpatialSceneCreationOptions } from './types/types'
+import { pointToPhysical } from './physicalMetrics'
 
 describe('test formatSceneConfig in window', () => {
   test('should format window with no unit', () => {
@@ -79,6 +86,23 @@ describe('test formatSceneConfig in window', () => {
     ])
   })
 
+  test('window mixed units: cm invalid and numbers treated as px', () => {
+    const config = {
+      defaultSize: {
+        width: '10cm',
+        height: 800,
+      },
+    } satisfies SpatialSceneCreationOptions
+    const [formatted, errors] = formatSceneConfig(config, 'window')
+    expect(errors).toEqual(['defaultSize.width'])
+    expect(formatted.defaultSize).toEqual(
+      expect.objectContaining({
+        height: 800,
+      }),
+    )
+    expect((formatted.defaultSize as any).width).toBeUndefined()
+  })
+
   test('should format window with meter', () => {
     const config = {
       defaultSize: {
@@ -106,6 +130,27 @@ describe('test formatSceneConfig in window', () => {
   })
 })
 
+describe('formatSceneConfig invalid unit (mixed)', () => {
+  test('volume defaultSize width cm invalid while numbers convert', () => {
+    const config = {
+      defaultSize: {
+        width: '10cm',
+        height: 1000,
+        depth: 100,
+      },
+    } satisfies SpatialSceneCreationOptions
+    const [formattedConfig, errors] = formatSceneConfig(config, 'volume')
+    expect(errors).toEqual(['defaultSize.width'])
+    expect(formattedConfig.defaultSize).toEqual(
+      expect.objectContaining({
+        height: pointToPhysical(1000),
+        depth: pointToPhysical(100),
+      }),
+    )
+    expect((formattedConfig.defaultSize as any).width).toBeUndefined()
+  })
+})
+
 describe('test formatSceneConfig in volume', () => {
   test('should format volume with no unit', () => {
     const config = {
@@ -123,15 +168,15 @@ describe('test formatSceneConfig in volume', () => {
     } satisfies SpatialSceneCreationOptions
     const [formattedConfig] = formatSceneConfig(config, 'volume')
     expect(formattedConfig.defaultSize).toEqual({
-      width: 1,
-      height: 1,
-      depth: 1,
+      width: pointToPhysical(1),
+      height: pointToPhysical(1),
+      depth: pointToPhysical(1),
     })
     expect(formattedConfig.resizability).toEqual({
-      minWidth: 1360,
-      minHeight: 1360,
-      maxWidth: 1360,
-      maxHeight: 1360,
+      minWidth: 1,
+      minHeight: 1,
+      maxWidth: 1,
+      maxHeight: 1,
     })
   })
 
@@ -316,7 +361,7 @@ describe('injectScenePolyfill should call xrCurrentSceneDefaults and update scen
 
     expect(mockFn).toHaveBeenCalledWith(
       expect.objectContaining({
-        defaultSize: { width: 0.94, height: 0.94, depth: 0.94 },
+        defaultSize: { width: '0.94m', height: '0.94m', depth: '0.94m' },
       }),
     )
 
@@ -324,12 +369,16 @@ describe('injectScenePolyfill should call xrCurrentSceneDefaults and update scen
     const { UpdateSceneConfig } = await import('./JSBCommand')
     expect(UpdateSceneConfig).toHaveBeenCalledWith({
       type: 'volume',
-      defaultSize: { width: 1, height: 1, depth: 1 },
+      defaultSize: {
+        width: pointToPhysical(1),
+        height: pointToPhysical(1),
+        depth: pointToPhysical(1),
+      },
       resizability: {
-        minWidth: 0.5 * 1360,
-        minHeight: 1 * 1360,
-        maxWidth: 0.5 * 1360,
-        maxHeight: 1 * 1360,
+        minWidth: 0.5,
+        minHeight: 1,
+        maxWidth: 0.5,
+        maxHeight: 1,
       },
     })
   })
@@ -341,7 +390,7 @@ describe('initScene should receive defaultScene config by type', () => {
       .fn()
       .mockResolvedValue({ defaultSize: { width: 800, height: 600 } })
 
-    initScene('sa', mockFn)
+    initScene('sa-no-type', mockFn)
 
     expect(mockFn).toHaveBeenCalledWith(
       expect.objectContaining({ defaultSize: { width: 1280, height: 720 } }),
@@ -353,7 +402,7 @@ describe('initScene should receive defaultScene config by type', () => {
       .fn()
       .mockResolvedValue({ defaultSize: { width: 800, height: 600 } })
 
-    initScene('sa', mockFn, { type: 'window' })
+    initScene('sa-window', mockFn, { type: 'window' })
 
     expect(mockFn).toHaveBeenCalledWith(
       expect.objectContaining({ defaultSize: { width: 1280, height: 720 } }),
@@ -365,12 +414,113 @@ describe('initScene should receive defaultScene config by type', () => {
       .fn()
       .mockResolvedValue({ defaultSize: { width: 800, height: 600 } })
 
-    initScene('sa', mockFn, { type: 'volume' })
+    initScene('sa-volume', mockFn, { type: 'volume' })
 
     expect(mockFn).toHaveBeenCalledWith(
       expect.objectContaining({
-        defaultSize: { width: 0.94, height: 0.94, depth: 0.94 },
+        defaultSize: { width: '0.94m', height: '0.94m', depth: '0.94m' },
       }),
     )
   })
+
+  it('with volume type and merge pre', () => {
+    const cb = vi.fn().mockImplementation(pre => ({
+      ...pre,
+      defaultSize: { ...(pre.defaultSize as any), depth: '0.1m' },
+    }))
+
+    // pre-snapshot should be empty before initScene writes configMap
+    const preSnap = __getSceneConfigSnapshotForTest('sa')
+    expect(preSnap).toBeUndefined()
+
+    initScene('sa', cb, { type: 'volume' })
+
+    expect(cb).toHaveBeenCalledWith(
+      expect.objectContaining({
+        defaultSize: { width: '0.94m', height: '0.94m', depth: '0.94m' },
+      }),
+    )
+
+    const snap = __getSceneConfigSnapshotForTest('sa')
+    expect(snap).toEqual(
+      expect.objectContaining({
+        type: 'volume',
+        defaultSize: { width: 0.94, height: 0.94, depth: 0.1 },
+      }),
+    )
+  })
+})
+
+describe('initScene callback chaining', () => {
+  it('passes previous return value as next pre argument', () => {
+    const firstReturn = { defaultSize: { width: 1000, height: 1000 } }
+    const cb1 = vi.fn().mockReturnValue(firstReturn)
+    initScene('sa-chain', cb1)
+    expect(cb1).toHaveBeenCalledWith(
+      expect.objectContaining({ defaultSize: { width: 1280, height: 720 } }),
+    )
+
+    const cb2 = vi.fn().mockReturnValue({})
+    initScene('sa-chain', cb2)
+    expect(cb2).toHaveBeenCalledWith(firstReturn)
+  })
+})
+
+describe('hijackWindowATag', () => {
+  afterEach(() => {
+    document.body.innerHTML = ''
+    document.onclick = null
+    vi.restoreAllMocks()
+  })
+
+  it('handles clicks on nested elements inside anchor tags', () => {
+    const openSpy = vi.spyOn(window, 'open').mockImplementation(() => null)
+    hijackWindowATag(window)
+
+    const anchor = document.createElement('a')
+    anchor.href = 'https://example.com/detail'
+    anchor.target = '_blank'
+
+    const image = document.createElement('img')
+    anchor.appendChild(image)
+    document.body.appendChild(anchor)
+
+    image.dispatchEvent(
+      new MouseEvent('click', { bubbles: true, cancelable: true }),
+    )
+
+    expect(openSpy).toHaveBeenCalledWith('https://example.com/detail', '_blank')
+  })
+})
+
+describe('hijackWindowATag – defaultPrevented', () => {
+  afterEach(() => {
+    document.body.innerHTML = ''
+    document.onclick = null
+    vi.restoreAllMocks()
+  })
+
+  it('does not open a new window when the click was already preventDefault-ed', () => {
+    const openSpy = vi.spyOn(window, 'open').mockImplementation(() => null)
+    hijackWindowATag(window)
+
+    const anchor = document.createElement('a')
+    anchor.href = 'https://example.com/detail'
+    anchor.target = '_blank'
+
+    const span = document.createElement('span')
+    anchor.appendChild(span)
+    document.body.appendChild(anchor)
+
+    // Simulate an app-level handler that cancels the click before the polyfill sees it.
+    span.addEventListener('click', ev => {
+      ev.preventDefault()
+    })
+
+    span.dispatchEvent(
+      new MouseEvent('click', { bubbles: true, cancelable: true }),
+    )
+
+    expect(openSpy).not.toHaveBeenCalled()
+  })
 })