@webspatial/core-sdk 1.0.5 → 1.2.0

package/src/platform-adapter/xr/XRPlatform.ts

@@ -0,0 +1,133 @@
+import { PlatformAbility, CommandResult } from '../interface'
+import {
+  CommandResultFailure,
+  CommandResultSuccess,
+} from '../CommandResultUtils'
+import { SpatialWebEvent } from '../../SpatialWebEvent'
+
+interface JSBResponse {
+  success: boolean
+  data: any
+}
+type JSBError = {
+  code: string
+  message: string
+}
+
+let requestId = 0
+
+const MAX_ID = 100000
+
+function nextRequestId() {
+  requestId = (requestId + 1) % MAX_ID
+  return `rId_${requestId}`
+}
+
+export class XRPlatform implements PlatformAbility {
+  async callJSB(cmd: string, msg: string): Promise<CommandResult> {
+    // android JS Bridge interface only support sync invoking
+    // in order to implement promise API, register every request by requestId and remove when resolve/reject.
+    return new Promise((resolve, reject) => {
+      try {
+        const rId = nextRequestId()
+
+        SpatialWebEvent.addEventReceiver(rId, (result: JSBResponse) => {
+          SpatialWebEvent.removeEventReceiver(rId)
+          if (result.success) {
+            resolve(CommandResultSuccess(result.data))
+          } else {
+            const { code, message } = result.data as JSBError
+            resolve(CommandResultFailure(code, message))
+          }
+        })
+
+        const ans = window.webspatialBridge.postMessage(rId, cmd, msg)
+        if (ans !== '') {
+          SpatialWebEvent.removeEventReceiver(rId)
+          // sync call
+          const result = JSON.parse(ans) as JSBResponse
+          if (result.success) {
+            resolve(CommandResultSuccess(result.data))
+          } else {
+            const { code, message } = result.data as JSBError
+            resolve(CommandResultFailure(code, message))
+          }
+        }
+      } catch (error: unknown) {
+        console.error(`XRPlatform cmd: ${cmd}, msg: ${msg} error: ${error}`)
+        const { code, message } = error as JSBError
+        resolve(CommandResultFailure(code, message))
+      }
+    })
+  }
+
+  async callWebSpatialProtocol(
+    command: string,
+    query?: string,
+    target?: string,
+    features?: string,
+  ): Promise<CommandResult> {
+    // Waiting for request to create spatial div
+    return new Promise((resolve, reject) => {
+      const createdId = nextRequestId()
+      try {
+        let windowProxy: any = null
+        SpatialWebEvent.addEventReceiver(
+          createdId,
+          (result: { spatialId: string }) => {
+            console.log('createdId', createdId, result.spatialId)
+            resolve(
+              CommandResultSuccess({
+                windowProxy: windowProxy,
+                id: result.spatialId,
+              }),
+            )
+            SpatialWebEvent.removeEventReceiver(createdId)
+          },
+        )
+        windowProxy = this.openWindow(
+          command,
+          query,
+          target,
+          features,
+        ).windowProxy
+        windowProxy?.open(`about:blank?rid=${createdId}`, '_self')
+      } catch (error: unknown) {
+        console.error(`open window error: ${error}`)
+        const { code, message } = error as JSBError
+        SpatialWebEvent.removeEventReceiver(createdId)
+        resolve(CommandResultFailure(code, message))
+      }
+    })
+  }
+
+  callWebSpatialProtocolSync(
+    command: string,
+    query?: string,
+    target?: string,
+    features?: string,
+  ): CommandResult {
+    const { spatialId: id = '', windowProxy } = this.openWindow(
+      command,
+      query,
+      target,
+      features,
+    )
+
+    return CommandResultSuccess({ windowProxy, id })
+  }
+
+  private openWindow(
+    command: string,
+    query?: string,
+    target?: string,
+    features?: string,
+  ) {
+    const windowProxy = window.open(
+      `webspatial://${command}?${query || ''}`,
+      target,
+      features,
+    )
+    return { spatialId: '', windowProxy }
+  }
+}

package/src/reality/component/index.ts

@@ -1,2 +1,2 @@
 export * from './SpatialComponent'
-export * from './ModelComponent'
+export * from './ModelComponent'

package/src/reality/entity/SpatialEntity.ts

@@ -164,13 +164,7 @@ export class SpatialEntity extends SpatialObject {
       this.dispatchEvent(evt)
     }
     // rotate
-    else if (type === SpatialWebMsgType.spatialrotatestart) {
-      const evt = createSpatialEvent(
-        SpatialWebMsgType.spatialrotatestart,
-        (data as SpatialRotateMsg).detail,
-      )
-      this.dispatchEvent(evt)
-    } else if (type === SpatialWebMsgType.spatialrotate) {
+    else if (type === SpatialWebMsgType.spatialrotate) {
       const evt = createSpatialEvent(
         SpatialWebMsgType.spatialrotate,
         (data as SpatialRotateMsg).detail,
@@ -184,13 +178,7 @@ export class SpatialEntity extends SpatialObject {
       this.dispatchEvent(evt)
     }
     // magnify
-    else if (type === SpatialWebMsgType.spatialmagnifystart) {
-      const evt = createSpatialEvent(
-        SpatialWebMsgType.spatialmagnifystart,
-        (data as SpatialMagnifyMsg).detail,
-      )
-      this.dispatchEvent(evt)
-    } else if (type === SpatialWebMsgType.spatialmagnify) {
+    else if (type === SpatialWebMsgType.spatialmagnify) {
       const evt = createSpatialEvent(
         SpatialWebMsgType.spatialmagnify,
         (data as SpatialMagnifyMsg).detail,
@@ -206,6 +194,10 @@ export class SpatialEntity extends SpatialObject {
   }
 
   dispatchEvent(evt: CustomEvent) {
+    // Set origin once at the first dispatch in the bubbling chain
+    if (!(evt as any).__origin) {
+      Object.defineProperty(evt, '__origin', { value: this, enumerable: false })
+    }
     this.events[evt.type]?.(evt)
     if (evt.bubbles && !evt.cancelBubble) {
       if (this.parent && this.parent instanceof SpatialEntity) {

package/src/reality/entity/index.ts

@@ -1,2 +1,2 @@
 export * from './SpatialEntity'
-export * from './SpatialModelEntity'
+export * from './SpatialModelEntity'

package/src/reality/geometry/SpatialBoxGeometry.ts

@@ -1,4 +1,7 @@
-import { SpatialBoxGeometryOptions, SpatialGeometryType } from '../../types/types'
+import {
+  SpatialBoxGeometryOptions,
+  SpatialGeometryType,
+} from '../../types/types'
 import { SpatialGeometry } from './SpatialGeometry'
 
 export class SpatialBoxGeometry extends SpatialGeometry {

package/src/reality/geometry/index.ts

@@ -3,4 +3,4 @@ export * from './SpatialBoxGeometry'
 export * from './SpatialSphereGeometry'
 export * from './SpatialCylinderGeometry'
 export * from './SpatialPlaneGeometry'
-export * from './SpatialConeGeometry'
+export * from './SpatialConeGeometry'

package/src/reality/material/index.ts

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

package/src/reality/resource/index.ts

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

package/src/scene-polyfill.ts

@@ -50,17 +50,37 @@ class SceneManager {
     return this.configMap[name]
   }
 
+  // Ensure URL is absolute; only convert when a relative path is provided
+  // - Keep external and special schemes untouched (http, https, data, blob, about, file, mailto, etc.)
+  // - Handle protocol-relative URLs (//example.com/path)
+  // - Resolve relative paths against document.baseURI (respects <base href>)
+  private ensureAbsoluteUrl(raw?: string): string | undefined {
+    if (!raw) return raw
+    // Already has a scheme (includes internal webspatial:// which is handled earlier)
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(raw)) {
+      return raw
+    }
+    // Protocol-relative URL
+    if (raw.startsWith('//')) {
+      return `${window.location.protocol}${raw}`
+    }
+    // Resolve against base URI
+    try {
+      return new URL(raw, document.baseURI).toString()
+    } catch {
+      // Fallback: leave unchanged
+      return raw
+    }
+  }
+
   private open = (url?: string, target?: string, features?: string) => {
     // bypass internal
     if (url?.startsWith(INTERNAL_SCHEMA_PREFIX)) {
       return this.originalOpen(url, target, features)
     }
 
-    //  absolute url
-    const prefix = `${window.location.protocol}//${window.location.host}`
-    if (!url?.startsWith(prefix)) {
-      url = prefix + url
-    }
+    // Normalize only relative URLs to absolute for platform handling
+    url = this.ensureAbsoluteUrl(url)
 
     // if target is special
     if (target === '_self' || target === '_parent' || target === '_top') {
@@ -72,10 +92,6 @@ class SceneManager {
     const cmd = new createSpatialSceneCommand(url!, cfg, target, features)
     const result = cmd.executeSync()
 
-    if (typeof target === 'string' && this.configMap[target]) {
-      delete this.configMap[target]
-    }
-
     const id = result.data?.id
 
     if (id) {

package/src/types/internal.ts

@@ -1,9 +1,9 @@
-import { SpatialSceneCreationOptions, SpatialSceneType } from "./types";
+import { SpatialSceneCreationOptions, SpatialSceneType } from './types'
 
-
-export type SpatialSceneCreationOptionsInternal = SpatialSceneCreationOptions & {
-  type: SpatialSceneType;
-};
+export type SpatialSceneCreationOptionsInternal =
+  SpatialSceneCreationOptions & {
+    type: SpatialSceneType
+  }
 export enum SpatialSceneState {
   idle = 'idle',
   pending = 'pending',

package/src/types/types.ts

@@ -11,6 +11,13 @@ export interface Vec3 {
 
 export type Point3D = Vec3
 
+export interface Quaternion {
+  x: number
+  y: number
+  z: number
+  w: number
+}
+
 /**
  * Material type for SpatialDiv or HTML document.
  *
@@ -69,10 +76,8 @@ export interface SpatializedElementProperties {
   enableDragStartGesture: boolean
   enableDragGesture: boolean
   enableDragEndGesture: boolean
-  enableRotateStartGesture: boolean
   enableRotateGesture: boolean
   enableRotateEndGesture: boolean
-  enableMagnifyStartGesture: boolean
   enableMagnifyGesture: boolean
   enableMagnifyEndGesture: boolean
 }
@@ -343,38 +348,39 @@ export interface SpatialTapEventDetail {
 
 export type SpatialTapEvent = CustomEvent<SpatialTapEventDetail>
 
-export interface SpatialDragEventDetail {
-  location3D: Point3D
+export interface SpatialDragStartEventDetail {
   startLocation3D: Point3D
+}
+
+export interface SpatialDragEventDetail {
   translation3D: Vec3
-  predictedEndTranslation3D: Vec3
-  predictedEndLocation3D: Point3D
-  velocity: Size
 }
 
-export type SpatialDragEvent = CustomEvent<SpatialDragEventDetail>
+export interface SpatialDragEndEventDetail {}
 
-export type SpatialDragEndEvent = SpatialDragEvent
+export type SpatialDragStartEvent = CustomEvent<SpatialDragStartEventDetail>
+
+export type SpatialDragEvent = CustomEvent<SpatialDragEventDetail>
 
+export type SpatialDragEndEvent = CustomEvent<SpatialDragEndEventDetail>
 export interface SpatialRotateEventDetail {
-  rotation: { vector: [number, number, number, number] }
-  startAnchor3D: Vec3
-  startLocation3D: Point3D
+  quaternion: Quaternion
 }
 
+export interface SpatialRotateEndEventDetail {}
+
 export type SpatialRotateEvent = CustomEvent<SpatialRotateEventDetail>
 
-export type SpatialRotateEndEvent = SpatialRotateEvent
+export type SpatialRotateEndEvent = CustomEvent<SpatialRotateEndEventDetail>
 
 export interface SpatialMagnifyEventDetail {
   magnification: number
-  velocity: number
-  startAnchor3D: Vec3
-  startLocation3D: Point3D
 }
 
+export interface SpatialMagnifyEndEventDetail {}
+
 export type SpatialMagnifyEvent = CustomEvent<SpatialMagnifyEventDetail>
 
-export type SpatialMagnifyEndEvent = SpatialMagnifyEvent
+export type SpatialMagnifyEndEvent = CustomEvent<SpatialMagnifyEndEventDetail>
 
 export type SpatialEntityOrReality = SpatialEntity | SpatializedDynamic3DElement