@webspatial/core-sdk 1.0.3 → 1.0.5

package/src/reality/geometry/SpatialSphereGeometry.ts

@@ -0,0 +1,15 @@
+import {
+  SpatialGeometryType,
+  SpatialSphereGeometryOptions,
+} from '../../types/types'
+import { SpatialGeometry } from './SpatialGeometry'
+
+export class SpatialSphereGeometry extends SpatialGeometry {
+  static type: SpatialGeometryType = 'SphereGeometry'
+  constructor(
+    public id: string,
+    public options: SpatialSphereGeometryOptions,
+  ) {
+    super(id, options)
+  }
+}

package/src/reality/geometry/index.ts

@@ -0,0 +1,6 @@
+export * from './SpatialGeometry'
+export * from './SpatialBoxGeometry'
+export * from './SpatialSphereGeometry'
+export * from './SpatialCylinderGeometry'
+export * from './SpatialPlaneGeometry'
+export * from './SpatialConeGeometry'

package/src/reality/index.ts

@@ -0,0 +1,5 @@
+export * from './entity'
+export * from './component'
+export * from './material'
+export * from './geometry'
+export * from './resource'

package/src/reality/material/SpatialMaterial.ts

@@ -0,0 +1,14 @@
+import { SpatialObject } from '../../SpatialObject'
+import { SpatialMaterialType } from '../../types/types'
+
+export abstract class SpatialMaterial extends SpatialObject {
+  constructor(
+    public id: string,
+    public type: SpatialMaterialType,
+  ) {
+    super(id)
+    this.type = type
+  }
+
+  abstract updateProperties(properties: any): void
+}

package/src/reality/material/SpatialUnlitMaterial.ts

@@ -0,0 +1,16 @@
+import { UpdateUnlitMaterialProperties } from '../../JSBCommand'
+import { SpatialUnlitMaterialOptions } from '../../types/types'
+import { SpatialMaterial } from './SpatialMaterial'
+
+export class SpatialUnlitMaterial extends SpatialMaterial {
+  constructor(
+    public id: string,
+    public options: SpatialUnlitMaterialOptions,
+  ) {
+    super(id, 'unlit')
+  }
+
+  updateProperties(properties: Partial<SpatialUnlitMaterialOptions>) {
+    return new UpdateUnlitMaterialProperties(this, properties).execute()
+  }
+}

package/src/reality/material/index.ts

@@ -0,0 +1,2 @@
+export * from './SpatialUnlitMaterial'
+export * from './SpatialMaterial'

package/src/reality/realityCreator.ts

@@ -0,0 +1,94 @@
+import {
+  CreateModelComponentCommand,
+  CreateModelAssetCommand,
+  CreateSpatialEntityCommand,
+  CreateSpatialGeometryCommand,
+  CreateSpatialModelEntityCommand,
+  CreateSpatialUnlitMaterialCommand,
+} from '../JSBCommand'
+import {
+  ModelComponentOptions,
+  ModelAssetOptions,
+  SpatialGeometryOptions,
+  SpatialModelEntityCreationOptions,
+  SpatialUnlitMaterialOptions,
+  SpatialEntityUserData,
+} from '../types/types'
+import { SpatialEntity, SpatialModelEntity } from './entity'
+import { ModelComponent } from './component'
+import { SpatialGeometry } from './geometry'
+import { SpatialUnlitMaterial } from './material'
+import { SpatialModelAsset } from './resource'
+
+export async function createSpatialEntity(
+  userData?: SpatialEntityUserData,
+): Promise<SpatialEntity> {
+  const result = await new CreateSpatialEntityCommand(userData?.name).execute()
+  if (!result.success) {
+    throw new Error('createSpatialEntity failed:' + result?.errorMessage)
+  } else {
+    const { id } = result.data
+    return new SpatialEntity(id, userData)
+  }
+}
+
+export async function createSpatialGeometry<T extends SpatialGeometry>(
+  ctor: new (...args: any[]) => T,
+  options: SpatialGeometryOptions,
+) {
+  const result = await new CreateSpatialGeometryCommand(
+    (ctor as any).type,
+    options,
+  ).execute()
+  if (!result.success) {
+    throw new Error('createSpatialGeometry failed:' + result?.errorMessage)
+  } else {
+    const { id } = result.data
+    return new ctor(id, options) as T
+  }
+}
+
+export async function createSpatialUnlitMaterial(
+  options: SpatialUnlitMaterialOptions,
+) {
+  const result = await new CreateSpatialUnlitMaterialCommand(options).execute()
+  if (!result.success) {
+    throw new Error('createSpatialUnlitMaterial failed:' + result?.errorMessage)
+  } else {
+    const { id } = result.data
+    return new SpatialUnlitMaterial(id, options)
+  }
+}
+
+export async function createModelComponent(options: ModelComponentOptions) {
+  const result = await new CreateModelComponentCommand(options).execute()
+  if (!result.success) {
+    throw new Error('createModelComponent failed:' + result?.errorMessage)
+  } else {
+    const { id } = result.data
+    return new ModelComponent(id, options)
+  }
+}
+
+export async function createSpatialModelEntity(
+  options: SpatialModelEntityCreationOptions,
+  userData?: SpatialEntityUserData,
+) {
+  const result = await new CreateSpatialModelEntityCommand(options).execute()
+  if (!result.success) {
+    throw new Error('createSpatialModelEntity failed:' + result?.errorMessage)
+  } else {
+    const { id } = result.data
+    return new SpatialModelEntity(id, options, userData)
+  }
+}
+
+export async function createModelAsset(options: ModelAssetOptions) {
+  const result = await new CreateModelAssetCommand(options).execute()
+  if (!result.success) {
+    throw new Error('createModelAsset failed:' + result?.errorMessage)
+  } else {
+    const { id } = result.data
+    return new SpatialModelAsset(id, options)
+  }
+}

package/src/reality/resource/SpatialModelAsset.ts

@@ -0,0 +1,11 @@
+import { SpatialObject } from '../../SpatialObject'
+import { ModelAssetOptions } from '../../types/types'
+
+export class SpatialModelAsset extends SpatialObject {
+  constructor(
+    public id: string,
+    public options: ModelAssetOptions,
+  ) {
+    super(id)
+  }
+}

package/src/reality/resource/index.ts

@@ -0,0 +1 @@
+export * from './SpatialModelAsset';

package/src/scene-polyfill.test.ts

@@ -0,0 +1,376 @@
+import { describe, expect, test, vi, beforeEach, afterEach, it } from 'vitest'
+import { formatSceneConfig, initScene, injectSceneHook } from './scene-polyfill'
+import { SpatialSceneCreationOptions } from './types/types'
+
+describe('test formatSceneConfig in window', () => {
+  test('should format window with no unit', () => {
+    const config = {
+      defaultSize: {
+        width: 100,
+        height: 100,
+      },
+      resizability: {
+        minWidth: 100,
+        minHeight: 100,
+        maxWidth: 100,
+        maxHeight: 100,
+      },
+    } satisfies SpatialSceneCreationOptions
+    const [formattedConfig] = formatSceneConfig(config, 'window')
+    expect(formattedConfig.defaultSize).toEqual({
+      width: 100,
+      height: 100,
+    })
+    expect(formattedConfig.resizability).toEqual({
+      minWidth: 100,
+      minHeight: 100,
+      maxWidth: 100,
+      maxHeight: 100,
+    })
+  })
+
+  test('should format window with px', () => {
+    const config = {
+      defaultSize: {
+        width: '100px',
+        height: '100px',
+      },
+      resizability: {
+        minWidth: '100px',
+        minHeight: '100px',
+        maxWidth: '100px',
+        maxHeight: '100px',
+      },
+    } satisfies SpatialSceneCreationOptions
+    const [formattedConfig] = formatSceneConfig(config, 'window')
+    expect(formattedConfig.defaultSize).toEqual({
+      width: 100,
+      height: 100,
+    })
+    expect(formattedConfig.resizability).toEqual({
+      minWidth: 100,
+      minHeight: 100,
+      maxWidth: 100,
+      maxHeight: 100,
+    })
+  })
+
+  test('should format window with invalid unit', () => {
+    const config = {
+      defaultSize: {
+        width: '100cm',
+        height: '100cm',
+      },
+      resizability: {
+        minWidth: '100cm',
+        minHeight: '100cm',
+        maxWidth: '100cm',
+        maxHeight: '100cm',
+      },
+    } satisfies SpatialSceneCreationOptions
+    const [, errors] = formatSceneConfig(config, 'window')
+    expect(errors).toEqual([
+      'defaultSize.width',
+      'defaultSize.height',
+      'resizability.minWidth',
+      'resizability.minHeight',
+      'resizability.maxWidth',
+      'resizability.maxHeight',
+    ])
+  })
+
+  test('should format window with meter', () => {
+    const config = {
+      defaultSize: {
+        width: '1m',
+        height: '1m',
+      },
+      resizability: {
+        minWidth: '1m',
+        minHeight: '1m',
+        maxWidth: '1m',
+        maxHeight: '1m',
+      },
+    } satisfies SpatialSceneCreationOptions
+    const [formattedConfig] = formatSceneConfig(config, 'window')
+    expect(formattedConfig.defaultSize).toEqual({
+      width: 1360,
+      height: 1360,
+    })
+    expect(formattedConfig.resizability).toEqual({
+      minWidth: 1360,
+      minHeight: 1360,
+      maxWidth: 1360,
+      maxHeight: 1360,
+    })
+  })
+})
+
+describe('test formatSceneConfig in volume', () => {
+  test('should format volume with no unit', () => {
+    const config = {
+      defaultSize: {
+        width: 1,
+        height: 1,
+        depth: 1,
+      },
+      resizability: {
+        minWidth: 1,
+        minHeight: 1,
+        maxWidth: 1,
+        maxHeight: 1,
+      },
+    } satisfies SpatialSceneCreationOptions
+    const [formattedConfig] = formatSceneConfig(config, 'volume')
+    expect(formattedConfig.defaultSize).toEqual({
+      width: 1,
+      height: 1,
+      depth: 1,
+    })
+    expect(formattedConfig.resizability).toEqual({
+      minWidth: 1360,
+      minHeight: 1360,
+      maxWidth: 1360,
+      maxHeight: 1360,
+    })
+  })
+
+  test('should format volume with px', () => {
+    const config = {
+      defaultSize: {
+        width: '1360px',
+        height: '1360px',
+        depth: '1360px',
+      },
+      resizability: {
+        minWidth: '1360px',
+        minHeight: '1360px',
+        maxWidth: '1360px',
+        maxHeight: '1360px',
+      },
+    } satisfies SpatialSceneCreationOptions
+    const [formattedConfig] = formatSceneConfig(config, 'volume')
+    expect(formattedConfig.defaultSize).toEqual({
+      width: 1,
+      height: 1,
+      depth: 1,
+    })
+    expect(formattedConfig.resizability).toEqual({
+      minWidth: 1360,
+      minHeight: 1360,
+      maxWidth: 1360,
+      maxHeight: 1360,
+    })
+  })
+
+  test('should format volume with meter', () => {
+    const config = {
+      defaultSize: {
+        width: '1m',
+        height: '1m',
+        depth: '1m',
+      },
+      resizability: {
+        minWidth: '1m',
+        minHeight: '1m',
+        maxWidth: '1m',
+        maxHeight: '1m',
+      },
+    } satisfies SpatialSceneCreationOptions
+    const [formattedConfig] = formatSceneConfig(config, 'volume')
+    expect(formattedConfig.defaultSize).toEqual({
+      width: 1,
+      height: 1,
+      depth: 1,
+    })
+    expect(formattedConfig.resizability).toEqual({
+      minWidth: 1360,
+      minHeight: 1360,
+      maxWidth: 1360,
+      maxHeight: 1360,
+    })
+  })
+
+  test('should format volume with invalid unit', () => {
+    const config = {
+      defaultSize: {
+        width: '100cm',
+        height: '100cm',
+        depth: '100cm',
+      },
+      resizability: {
+        minWidth: '100cm',
+        minHeight: '100cm',
+        maxWidth: '100cm',
+        maxHeight: '100cm',
+      },
+    } satisfies SpatialSceneCreationOptions
+    const [, errors] = formatSceneConfig(config, 'volume')
+    expect(errors).toEqual([
+      'defaultSize.width',
+      'defaultSize.height',
+      'defaultSize.depth',
+      'resizability.minWidth',
+      'resizability.minHeight',
+      'resizability.maxWidth',
+      'resizability.maxHeight',
+    ])
+  })
+})
+
+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),
+    })),
+  }
+})
+
+describe('injectScenePolyfill should call xrCurrentSceneDefaults and update scene config', () => {
+  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('with window type', 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'
+
+    injectSceneHook()
+
+    document.dispatchEvent(new Event('DOMContentLoaded'))
+
+    await vi.runAllTimersAsync()
+
+    expect(mockFn).toHaveBeenCalledWith(
+      expect.objectContaining({
+        defaultSize: { width: 0.94, height: 0.94, depth: 0.94 },
+      }),
+    )
+
+    // verify UpdateSceneConfig.execute
+    const { UpdateSceneConfig } = await import('./JSBCommand')
+    expect(UpdateSceneConfig).toHaveBeenCalledWith({
+      type: 'volume',
+      defaultSize: { width: 1, height: 1, depth: 1 },
+      resizability: {
+        minWidth: 0.5 * 1360,
+        minHeight: 1 * 1360,
+        maxWidth: 0.5 * 1360,
+        maxHeight: 1 * 1360,
+      },
+    })
+  })
+})
+
+describe('initScene should receive defaultScene config by type', () => {
+  it('with no type', async () => {
+    const mockFn = vi
+      .fn()
+      .mockResolvedValue({ defaultSize: { width: 800, height: 600 } })
+
+    initScene('sa', mockFn)
+
+    expect(mockFn).toHaveBeenCalledWith(
+      expect.objectContaining({ defaultSize: { width: 1280, height: 720 } }),
+    )
+  })
+
+  it('with window type', async () => {
+    const mockFn = vi
+      .fn()
+      .mockResolvedValue({ defaultSize: { width: 800, height: 600 } })
+
+    initScene('sa', mockFn, { type: 'window' })
+
+    expect(mockFn).toHaveBeenCalledWith(
+      expect.objectContaining({ defaultSize: { width: 1280, height: 720 } }),
+    )
+  })
+
+  it('with volume type', async () => {
+    const mockFn = vi
+      .fn()
+      .mockResolvedValue({ defaultSize: { width: 800, height: 600 } })
+
+    initScene('sa', mockFn, { type: 'volume' })
+
+    expect(mockFn).toHaveBeenCalledWith(
+      expect.objectContaining({
+        defaultSize: { width: 0.94, height: 0.94, depth: 0.94 },
+      }),
+    )
+  })
+})