@webspatial/core-sdk 1.7.0 → 2.0.0

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

@@ -1,17 +1,35 @@
-import { describe, it, expect, vi } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const jsbMocks = vi.hoisted(() => ({
+  createSpatialSceneCommand: vi.fn().mockImplementation(() => ({
+    executeSync: vi.fn().mockReturnValue({
+      data: { id: 'scene-1', windowProxy: {} },
+    }),
+  })),
+  focusSceneExecute: vi.fn().mockResolvedValue(undefined),
+}))
 
-vi.mock('./spatial-host', () => ({
+const spatialHostMocks = vi.hoisted(() => ({
   openSpatialSceneSync: vi.fn().mockReturnValue({
     success: true,
     data: { id: 'scene-1', windowProxy: {} },
   }),
 }))
 
+const originalWindowOpen = window.open
+
+vi.mock('./spatial-host', () => ({
+  openSpatialSceneSync: spatialHostMocks.openSpatialSceneSync,
+}))
+
 vi.mock('./JSBCommand', () => {
   return {
-    FocusScene: vi.fn().mockImplementation(() => ({
-      execute: vi.fn().mockResolvedValue(undefined),
-    })),
+    createSpatialSceneCommand: jsbMocks.createSpatialSceneCommand,
+    FocusScene: vi.fn().mockImplementation(function () {
+      return {
+        execute: jsbMocks.focusSceneExecute,
+      }
+    }),
   }
 })
 
@@ -31,6 +49,16 @@ async function waitTick() {
   await new Promise(r => setTimeout(r, 0))
 }
 
+afterEach(() => {
+  window.open = originalWindowOpen
+  jsbMocks.createSpatialSceneCommand.mockClear()
+  jsbMocks.focusSceneExecute.mockClear()
+  spatialHostMocks.openSpatialSceneSync.mockClear()
+  document
+    .querySelectorAll('link[rel="manifest"]')
+    .forEach(node => node.parentElement?.removeChild(node))
+})
+
 describe('setupManifest applies overrides to xr_window_defaults / xr_volume_defaults', () => {
   it('applies window overrides without affecting volume defaults', async () => {
     vi.resetModules()
@@ -111,6 +139,279 @@ describe('setupManifest applies overrides to xr_window_defaults / xr_volume_defa
     cleanup()
   })
 
+  it('prefers snake_case over camelCase within a layer and still applies overrides by priority', async () => {
+    vi.resetModules()
+    const cleanup = addDataManifest({
+      xr_spatial_scene: {
+        defaultSize: { width: '111px', height: '111px' },
+        default_size: { width: '222px', height: '333px' },
+        overrides: {
+          window_scene: {
+            defaultSize: { width: '444px' },
+            default_size: { width: '555px' },
+          },
+        },
+      },
+    })
+    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' },
+    )
+
+    expect(winDefaults).toEqual(
+      expect.objectContaining({
+        defaultSize: { width: '555px', height: '333px' },
+      }),
+    )
+
+    expect(volDefaults).toEqual(
+      expect.objectContaining({
+        defaultSize: { width: '222px', height: '333px' },
+      }),
+    )
+
+    cleanup()
+  })
+
+  it('resolves same-layer aliases recursively so winners own their layer values', async () => {
+    vi.resetModules()
+    const cleanup = addDataManifest({
+      xr_spatial_scene: {
+        defaultSize: { width: '111px', height: '111px' },
+        default_size: { width: '222px', height: '333px' },
+        resizability: {
+          minWidth: '100px',
+          min_width: '200px',
+          maxWidth: '800px',
+        },
+      },
+    })
+    const { hijackWindowOpen, initScene } = await import('./scene-polyfill')
+    hijackWindowOpen(window)
+    await waitTick()
+
+    let defaults: any
+    initScene(
+      'recursive-layer',
+      pre => {
+        defaults = pre
+        return pre
+      },
+      { type: 'window' },
+    )
+
+    expect(defaults).toEqual(
+      expect.objectContaining({
+        defaultSize: { width: '222px', height: '333px' },
+        resizability: {
+          minWidth: '200px',
+          maxWidth: '800px',
+        },
+      }),
+    )
+
+    cleanup()
+  })
+
+  it('supports overrides windowScene/volumeScene and snake_case resizability keys', async () => {
+    vi.resetModules()
+    const cleanup = addDataManifest({
+      xr_spatial_scene: {
+        resizability: {
+          min_width: '300px',
+          min_height: '400px',
+          max_width: '1200px',
+          max_height: '1300px',
+        },
+        worldScaling: 'automatic',
+        overrides: {
+          windowScene: {
+            world_scaling: 'dynamic',
+          },
+          volumeScene: {
+            baseplate_visibility: 'hidden',
+          },
+        },
+      },
+    })
+    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' },
+    )
+
+    expect(winDefaults).toEqual(
+      expect.objectContaining({
+        resizability: {
+          minWidth: '300px',
+          minHeight: '400px',
+          maxWidth: '1200px',
+          maxHeight: '1300px',
+        },
+        worldScaling: 'dynamic',
+      }),
+    )
+
+    expect(volDefaults).toEqual(
+      expect.objectContaining({
+        resizability: {
+          minWidth: '300px',
+          minHeight: '400px',
+          maxWidth: '1200px',
+          maxHeight: '1300px',
+        },
+        baseplateVisibility: 'hidden',
+      }),
+    )
+
+    cleanup()
+  })
+
+  it('normalizes top-level world_alignment and baseplate_visibility aliases', async () => {
+    vi.resetModules()
+    const cleanup = addDataManifest({
+      xr_spatial_scene: {
+        world_alignment: 'gravityAligned',
+        baseplate_visibility: 'hidden',
+      },
+    })
+    const { hijackWindowOpen, initScene } = await import('./scene-polyfill')
+    hijackWindowOpen(window)
+    await waitTick()
+
+    let winDefaults: any
+    initScene(
+      'w-alias',
+      pre => {
+        winDefaults = pre
+        return pre
+      },
+      { type: 'window' },
+    )
+
+    let volDefaults: any
+    initScene(
+      'v-alias',
+      pre => {
+        volDefaults = pre
+        return pre
+      },
+      { type: 'volume' },
+    )
+
+    expect(winDefaults).toEqual(
+      expect.objectContaining({
+        worldAlignment: 'gravityAligned',
+        baseplateVisibility: 'hidden',
+      }),
+    )
+    expect(volDefaults).toEqual(
+      expect.objectContaining({
+        worldAlignment: 'gravityAligned',
+        baseplateVisibility: 'hidden',
+      }),
+    )
+
+    cleanup()
+  })
+
+  it('does not normalize initScene callback return value when chaining', async () => {
+    vi.resetModules()
+    const cleanup = addDataManifest({
+      xr_spatial_scene: {
+        default_size: { width: '222px', height: '333px' },
+      },
+    })
+    const { hijackWindowOpen, initScene } = await import('./scene-polyfill')
+    hijackWindowOpen(window)
+    await waitTick()
+
+    const firstReturn: any = { default_size: { width: '777px' } }
+    const cb1 = vi.fn().mockReturnValue(firstReturn)
+    initScene('chain', cb1, { type: 'window' })
+
+    const cb2 = vi.fn().mockReturnValue({})
+    initScene('chain', cb2, { type: 'window' })
+
+    expect(cb2).toHaveBeenCalledWith(firstReturn)
+
+    cleanup()
+  })
+
+  it('uses manifest aliases when window.open creates a named scene without initScene', async () => {
+    vi.resetModules()
+    const cleanup = addDataManifest({
+      xr_spatial_scene: {
+        default_size: { width: '300px', height: '400px' },
+        world_alignment: 'gravityAligned',
+        overrides: {
+          windowScene: {
+            default_size: { width: '500px' },
+            resizability: { min_width: '320px' },
+            baseplate_visibility: 'visible',
+          },
+        },
+      },
+    })
+    const { hijackWindowOpen } = await import('./scene-polyfill')
+    hijackWindowOpen(window)
+    await waitTick()
+
+    window.open('https://example.com/scene', 'manifest-alias-window')
+
+    expect(spatialHostMocks.openSpatialSceneSync).toHaveBeenCalledWith(
+      'https://example.com/scene',
+      expect.objectContaining({
+        type: 'window',
+        defaultSize: { width: 500, height: 400 },
+        resizability: { minWidth: 320 },
+        worldAlignment: 'gravityAligned',
+        baseplateVisibility: 'visible',
+      }),
+      'manifest-alias-window',
+      undefined,
+    )
+
+    cleanup()
+  })
+
   it('applies volume overrides without affecting window defaults', async () => {
     vi.resetModules()
     const cleanup = addDataManifest({

package/src/scene-polyfill.request-metadata.test.ts

@@ -0,0 +1,39 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+describe('scene polyfill request metadata forwarding', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+    vi.resetModules()
+    delete (window as any).webSpatial
+    delete (window as any).__webspatialShell__
+  })
+
+  it.each(['createSpatialized2DElement', 'createAttachment'])(
+    'forwards rid and wsepoch for %s without introducing extra request fields',
+    async command => {
+      ;(window as any).webSpatial = {
+        genToken: vi.fn(() => 'token-123'),
+      }
+      const originalOpen = vi.fn(() => null)
+      vi.spyOn(window, 'open').mockImplementation(originalOpen)
+
+      const { hijackWindowOpen } = await import('./scene-polyfill')
+      hijackWindowOpen(window)
+
+      window.open(`webspatial://${command}?rid=req_1&wsepoch=9`, '_blank')
+
+      expect(originalOpen).toHaveBeenCalled()
+      const redirectedUrl = (originalOpen.mock.calls as unknown[][])[0]?.[0]
+      expect(typeof redirectedUrl).toBe('string')
+      const redirected = new URL(String(redirectedUrl))
+      if (redirected.protocol === 'webspatial:') {
+        expect(redirected.host).toBe(command)
+      } else {
+        expect(redirected.searchParams.get('command')).toBe(command)
+      }
+      expect(redirected.searchParams.get('rid')).toBe('req_1')
+      expect(redirected.searchParams.get('wsepoch')).toBe('9')
+      expect(redirected.searchParams.get('wsrid')).toBeNull()
+    },
+  )
+})

package/src/scene-polyfill.test.ts

@@ -265,93 +265,51 @@ describe('test formatSceneConfig in volume', () => {
 
 vi.mock('./JSBCommand', () => {
   return {
-    GetSpatialSceneState: vi.fn().mockImplementation(() => ({
-      execute: vi.fn().mockResolvedValue({ data: { name: 'pending' } }),
-    })),
-    UpdateSceneConfig: vi.fn().mockImplementation(() => ({
-      execute: vi.fn().mockResolvedValue(undefined),
-    })),
-    UpdateSpatialSceneProperties: vi.fn().mockImplementation(() => ({
-      execute: vi.fn().mockResolvedValue(undefined),
-    })),
-    AddSpatializedElementToSpatialScene: vi.fn().mockImplementation(() => ({
-      execute: vi.fn().mockResolvedValue(undefined),
-    })),
+    GetSpatialSceneState: vi.fn().mockImplementation(function () {
+      return {
+        execute: vi.fn().mockResolvedValue({ data: { name: 'pending' } }),
+      }
+    }),
+    UpdateSceneConfig: vi.fn().mockImplementation(function () {
+      return {
+        execute: vi.fn().mockResolvedValue(undefined),
+      }
+    }),
+    UpdateSpatialSceneProperties: vi.fn().mockImplementation(function () {
+      return {
+        execute: vi.fn().mockResolvedValue(undefined),
+      }
+    }),
+    AddSpatializedElementToSpatialScene: vi
+      .fn()
+      .mockImplementation(function () {
+        return {
+          execute: vi.fn().mockResolvedValue(undefined),
+        }
+      }),
   }
 })
 
-describe('injectScenePolyfill should call xrCurrentSceneDefaults and update scene config', () => {
+describe('removed scene window globals', () => {
   beforeEach(() => {
     ;(window as any).opener = {}
   })
 
-  it('with no type', async () => {
-    vi.useFakeTimers()
-
-    const mockFn = vi
-      .fn()
-      .mockResolvedValue({ defaultSize: { width: 800, height: 600 } })
-    window.xrCurrentSceneDefaults = mockFn
-
-    injectSceneHook()
-
-    document.dispatchEvent(new Event('DOMContentLoaded'))
-
-    await vi.runAllTimersAsync()
-
-    expect(mockFn).toHaveBeenCalledWith(
-      expect.objectContaining({ defaultSize: { width: 1280, height: 720 } }),
-    )
-
-    // verify UpdateSceneConfig.execute
-    const { UpdateSceneConfig } = await import('./JSBCommand')
-    expect(UpdateSceneConfig).toHaveBeenCalledWith({
-      type: 'window',
-      defaultSize: { width: 800, height: 600 },
-    })
+  it('does not type removed window scene globals', () => {
+    // @ts-expect-error removed undocumented scene global
+    void window.xrCurrentSceneDefaults
+    // @ts-expect-error removed undocumented scene global
+    void window.xrCurrentSceneType
   })
 
-  it('with window type', async () => {
+  it('does not use opened-page globals to override pending scene config', async () => {
     vi.useFakeTimers()
 
     const mockFn = vi
       .fn()
       .mockResolvedValue({ defaultSize: { width: 800, height: 600 } })
-    window.xrCurrentSceneDefaults = mockFn
-    window.xrCurrentSceneType = 'window'
-
-    injectSceneHook()
-
-    document.dispatchEvent(new Event('DOMContentLoaded'))
-
-    await vi.runAllTimersAsync()
-
-    expect(mockFn).toHaveBeenCalledWith(
-      expect.objectContaining({ defaultSize: { width: 1280, height: 720 } }),
-    )
-
-    // verify UpdateSceneConfig.execute
-    const { UpdateSceneConfig } = await import('./JSBCommand')
-    expect(UpdateSceneConfig).toHaveBeenCalledWith({
-      type: 'window',
-      defaultSize: { width: 800, height: 600 },
-    })
-  })
-
-  it('with volume type', async () => {
-    vi.useFakeTimers()
-
-    const mockFn = vi.fn().mockResolvedValue({
-      defaultSize: { width: 1, height: 1, depth: 1 },
-      resizability: {
-        minWidth: 0.5,
-        minHeight: 1,
-        maxWidth: 0.5,
-        maxHeight: 1,
-      },
-    })
-    window.xrCurrentSceneDefaults = mockFn
-    window.xrCurrentSceneType = 'volume'
+    ;(window as any).xrCurrentSceneDefaults = mockFn
+    ;(window as any).xrCurrentSceneType = 'volume'
 
     injectSceneHook()
 
@@ -359,28 +317,9 @@ describe('injectScenePolyfill should call xrCurrentSceneDefaults and update scen
 
     await vi.runAllTimersAsync()
 
-    expect(mockFn).toHaveBeenCalledWith(
-      expect.objectContaining({
-        defaultSize: { width: '0.94m', height: '0.94m', depth: '0.94m' },
-      }),
-    )
-
-    // verify UpdateSceneConfig.execute
     const { UpdateSceneConfig } = await import('./JSBCommand')
-    expect(UpdateSceneConfig).toHaveBeenCalledWith({
-      type: 'volume',
-      defaultSize: {
-        width: pointToPhysical(1),
-        height: pointToPhysical(1),
-        depth: pointToPhysical(1),
-      },
-      resizability: {
-        minWidth: 0.5,
-        minHeight: 1,
-        maxWidth: 0.5,
-        maxHeight: 1,
-      },
-    })
+    expect(mockFn).not.toHaveBeenCalled()
+    expect(UpdateSceneConfig).not.toHaveBeenCalled()
   })
 })