@webspatial/core-sdk 1.0.5 → 1.2.0

package/dist/index.d.ts

@@ -55,10 +55,8 @@ declare enum SpatialWebMsgType {
     spatialdragstart = "spatialdragstart",
     spatialdrag = "spatialdrag",
     spatialdragend = "spatialdragend",
-    spatialrotatestart = "spatialrotatestart",
     spatialrotate = "spatialrotate",
     spatialrotateend = "spatialrotateend",
-    spatialmagnifystart = "spatialmagnifystart",
     spatialmagnify = "spatialmagnify",
     spatialmagnifyend = "spatialmagnifyend",
     objectdestroy = "objectdestroy"
@@ -89,13 +87,17 @@ interface SpatialTapMsg {
     type: SpatialWebMsgType.spatialtap;
     detail: SpatialTapEventDetail;
 }
+interface SpatialDragStartMsg {
+    type: SpatialWebMsgType.spatialdragstart;
+    detail: SpatialDragStartEventDetail;
+}
 interface SpatialDragMsg {
     type: SpatialWebMsgType.spatialdrag;
     detail: SpatialDragEventDetail;
 }
 interface SpatialDragEndMsg {
     type: SpatialWebMsgType.spatialdragend;
-    detail: SpatialDragEventDetail;
+    detail: SpatialDragEndEventDetail;
 }
 interface SpatialRotateMsg {
     type: SpatialWebMsgType.spatialrotate;
@@ -167,26 +169,19 @@ declare abstract class SpatializedElement extends SpatialObject {
      * Handles various spatial events like transforms, gestures, and interactions.
      * @param data The event data received from the WebSpatial system
      */
-    protected onReceiveEvent(data: CubeInfoMsg | TransformMsg | SpatialTapMsg | SpatialDragMsg | SpatialDragEndMsg | SpatialRotateMsg | SpatialRotateEndMsg | ObjectDestroyMsg): void;
+    protected onReceiveEvent(data: CubeInfoMsg | TransformMsg | SpatialTapMsg | SpatialDragStartMsg | SpatialDragMsg | SpatialDragEndMsg | SpatialRotateMsg | SpatialRotateEndMsg | ObjectDestroyMsg): void;
     private _onSpatialTap?;
     set onSpatialTap(value: (event: SpatialTapEvent) => void | undefined);
-    private _isDragging;
     private _onSpatialDragStart?;
-    set onSpatialDragStart(value: (event: SpatialDragEvent) => void | undefined);
+    set onSpatialDragStart(value: (event: SpatialDragStartEvent) => void | undefined);
     private _onSpatialDrag?;
     set onSpatialDrag(value: (event: SpatialDragEvent) => void | undefined);
     private _onSpatialDragEnd?;
     set onSpatialDragEnd(value: ((event: SpatialDragEndEvent) => void) | undefined);
-    private _isRotating;
-    private _onSpatialRotateStart?;
-    set onSpatialRotateStart(value: ((event: SpatialRotateEvent) => void) | undefined);
     private _onSpatialRotate?;
     set onSpatialRotate(value: ((event: SpatialRotateEvent) => void) | undefined);
     private _onSpatialRotateEnd?;
     set onSpatialRotateEnd(value: ((event: SpatialRotateEndEvent) => void) | undefined);
-    private _isMagnify;
-    private _onSpatialMagnifyStart?;
-    set onSpatialMagnifyStart(value: ((event: SpatialMagnifyEvent) => void) | undefined);
     private _onSpatialMagnify?;
     set onSpatialMagnify(value: ((event: SpatialMagnifyEvent) => void) | undefined);
     private _onSpatialMagnifyEnd?;
@@ -211,6 +206,12 @@ interface Vec3 {
     z: number;
 }
 type Point3D = Vec3;
+interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
 /**
  * Material type for SpatialDiv or HTML document.
  *
@@ -259,10 +260,8 @@ interface SpatializedElementProperties {
     enableDragStartGesture: boolean;
     enableDragGesture: boolean;
     enableDragEndGesture: boolean;
-    enableRotateStartGesture: boolean;
     enableRotateGesture: boolean;
     enableRotateEndGesture: boolean;
-    enableMagnifyStartGesture: boolean;
     enableMagnifyGesture: boolean;
     enableMagnifyEndGesture: boolean;
 }
@@ -405,33 +404,31 @@ interface SpatialTapEventDetail {
     location3D: Point3D;
 }
 type SpatialTapEvent = CustomEvent<SpatialTapEventDetail>;
-interface SpatialDragEventDetail {
-    location3D: Point3D;
+interface SpatialDragStartEventDetail {
     startLocation3D: Point3D;
+}
+interface SpatialDragEventDetail {
     translation3D: Vec3;
-    predictedEndTranslation3D: Vec3;
-    predictedEndLocation3D: Point3D;
-    velocity: Size;
 }
+interface SpatialDragEndEventDetail {
+}
+type SpatialDragStartEvent = CustomEvent<SpatialDragStartEventDetail>;
 type SpatialDragEvent = CustomEvent<SpatialDragEventDetail>;
-type SpatialDragEndEvent = SpatialDragEvent;
+type SpatialDragEndEvent = CustomEvent<SpatialDragEndEventDetail>;
 interface SpatialRotateEventDetail {
-    rotation: {
-        vector: [number, number, number, number];
-    };
-    startAnchor3D: Vec3;
-    startLocation3D: Point3D;
+    quaternion: Quaternion;
+}
+interface SpatialRotateEndEventDetail {
 }
 type SpatialRotateEvent = CustomEvent<SpatialRotateEventDetail>;
-type SpatialRotateEndEvent = SpatialRotateEvent;
+type SpatialRotateEndEvent = CustomEvent<SpatialRotateEndEventDetail>;
 interface SpatialMagnifyEventDetail {
     magnification: number;
-    velocity: number;
-    startAnchor3D: Vec3;
-    startLocation3D: Point3D;
+}
+interface SpatialMagnifyEndEventDetail {
 }
 type SpatialMagnifyEvent = CustomEvent<SpatialMagnifyEventDetail>;
-type SpatialMagnifyEndEvent = SpatialMagnifyEvent;
+type SpatialMagnifyEndEvent = CustomEvent<SpatialMagnifyEndEventDetail>;
 type SpatialEntityOrReality = SpatialEntity | SpatializedDynamic3DElement;
 
 declare class SpatialComponent extends SpatialObject {
@@ -670,7 +667,7 @@ declare class SpatializedStatic3DElement extends SpatializedElement {
      * @param callback Function to call when the model fails to load
      */
     set onLoadFailureCallback(callback: undefined | (() => void));
-    updateModelTransform(transform: DOMMatrix): void;
+    updateModelTransform(transform: DOMMatrixReadOnly): void;
 }
 
 /**
@@ -859,4 +856,4 @@ declare global {
 
 declare const isSSREnv: () => boolean;
 
-export { type BackgroundMaterialType, type BaseplateVisibilityType, BaseplateVisibilityValues, type CornerRadius, CubeInfo$1 as CubeInfo, type ModelAssetOptions, ModelComponent, type ModelComponentOptions, type Point3D, type Size, type Size3D, Spatial, SpatialBoxGeometry, type SpatialBoxGeometryOptions, SpatialComponent, SpatialConeGeometry, type SpatialConeGeometryOptions, SpatialCylinderGeometry, type SpatialCylinderGeometryOptions, type SpatialDragEndEvent, type SpatialDragEvent, type SpatialDragEventDetail, SpatialEntity, type SpatialEntityEventType, type SpatialEntityOrReality, type SpatialEntityProperties, type SpatialEntityUserData, SpatialGeometry, type SpatialGeometryOptions, type SpatialGeometryType, type SpatialMagnifyEndEvent, type SpatialMagnifyEvent, type SpatialMagnifyEventDetail, SpatialMaterial, type SpatialMaterialType, SpatialModelAsset, type SpatialModelDragEvent, SpatialModelEntity, type SpatialModelEntityCreationOptions, SpatialObject, SpatialPlaneGeometry, type SpatialPlaneGeometryOptions, type SpatialRotateEndEvent, type SpatialRotateEvent, type SpatialRotateEventDetail, SpatialScene, type SpatialSceneCreationOptions$1 as SpatialSceneCreationOptions, type SpatialSceneProperties, SpatialSceneState$1 as SpatialSceneState, type SpatialSceneType$1 as SpatialSceneType, SpatialSceneValues, SpatialSession, SpatialSphereGeometry, type SpatialSphereGeometryOptions, type SpatialTapEvent, type SpatialTapEventDetail, SpatialUnlitMaterial, type SpatialUnlitMaterialOptions, Spatialized2DElement, type Spatialized2DElementProperties, SpatializedDynamic3DElement, SpatializedElement, type SpatializedElementProperties, SpatializedElementType, SpatializedStatic3DElement, type SpatializedStatic3DElementProperties, type Vec3, type WorldAlignmentType, WorldAlignmentValues, type WorldScalingType, WorldScalingValues, isSSREnv, isValidBaseplateVisibilityType, isValidSceneUnit, isValidSpatialSceneType, isValidWorldAlignmentType, isValidWorldScalingType };
+export { type BackgroundMaterialType, type BaseplateVisibilityType, BaseplateVisibilityValues, type CornerRadius, CubeInfo$1 as CubeInfo, type ModelAssetOptions, ModelComponent, type ModelComponentOptions, type Point3D, type Quaternion, type Size, type Size3D, Spatial, SpatialBoxGeometry, type SpatialBoxGeometryOptions, SpatialComponent, SpatialConeGeometry, type SpatialConeGeometryOptions, SpatialCylinderGeometry, type SpatialCylinderGeometryOptions, type SpatialDragEndEvent, type SpatialDragEndEventDetail, type SpatialDragEvent, type SpatialDragEventDetail, type SpatialDragStartEvent, type SpatialDragStartEventDetail, SpatialEntity, type SpatialEntityEventType, type SpatialEntityOrReality, type SpatialEntityProperties, type SpatialEntityUserData, SpatialGeometry, type SpatialGeometryOptions, type SpatialGeometryType, type SpatialMagnifyEndEvent, type SpatialMagnifyEndEventDetail, type SpatialMagnifyEvent, type SpatialMagnifyEventDetail, SpatialMaterial, type SpatialMaterialType, SpatialModelAsset, type SpatialModelDragEvent, SpatialModelEntity, type SpatialModelEntityCreationOptions, SpatialObject, SpatialPlaneGeometry, type SpatialPlaneGeometryOptions, type SpatialRotateEndEvent, type SpatialRotateEndEventDetail, type SpatialRotateEvent, type SpatialRotateEventDetail, SpatialScene, type SpatialSceneCreationOptions$1 as SpatialSceneCreationOptions, type SpatialSceneProperties, SpatialSceneState$1 as SpatialSceneState, type SpatialSceneType$1 as SpatialSceneType, SpatialSceneValues, SpatialSession, SpatialSphereGeometry, type SpatialSphereGeometryOptions, type SpatialTapEvent, type SpatialTapEventDetail, SpatialUnlitMaterial, type SpatialUnlitMaterialOptions, Spatialized2DElement, type Spatialized2DElementProperties, SpatializedDynamic3DElement, SpatializedElement, type SpatializedElementProperties, SpatializedElementType, SpatializedStatic3DElement, type SpatializedStatic3DElementProperties, type Vec3, type WorldAlignmentType, WorldAlignmentValues, type WorldScalingType, WorldScalingValues, isSSREnv, isValidBaseplateVisibilityType, isValidSceneUnit, isValidSpatialSceneType, isValidWorldAlignmentType, isValidWorldScalingType };

package/dist/index.js

@@ -2,7 +2,7 @@
     (function(){
       if(typeof window === 'undefined') return;
       if(!window.__webspatialsdk__) window.__webspatialsdk__ = {}
-      window.__webspatialsdk__['core-sdk-version'] = "1.0.5"
+      window.__webspatialsdk__['core-sdk-version'] = "1.2.0"
   })()
     
 var __defProp = Object.defineProperty;
@@ -115,16 +115,119 @@ var init_SpatialWebEvent = __esm({
   }
 });
 
+// src/platform-adapter/xr/XRPlatform.ts
+var XRPlatform_exports = {};
+__export(XRPlatform_exports, {
+  XRPlatform: () => XRPlatform
+});
+function nextRequestId() {
+  requestId = (requestId + 1) % MAX_ID;
+  return `rId_${requestId}`;
+}
+var requestId, MAX_ID, XRPlatform;
+var init_XRPlatform = __esm({
+  "src/platform-adapter/xr/XRPlatform.ts"() {
+    "use strict";
+    init_CommandResultUtils();
+    init_SpatialWebEvent();
+    requestId = 0;
+    MAX_ID = 1e5;
+    XRPlatform = class {
+      async callJSB(cmd, msg) {
+        return new Promise((resolve, reject) => {
+          try {
+            const rId = nextRequestId();
+            SpatialWebEvent.addEventReceiver(rId, (result) => {
+              SpatialWebEvent.removeEventReceiver(rId);
+              if (result.success) {
+                resolve(CommandResultSuccess(result.data));
+              } else {
+                const { code, message } = result.data;
+                resolve(CommandResultFailure(code, message));
+              }
+            });
+            const ans = window.webspatialBridge.postMessage(rId, cmd, msg);
+            if (ans !== "") {
+              SpatialWebEvent.removeEventReceiver(rId);
+              const result = JSON.parse(ans);
+              if (result.success) {
+                resolve(CommandResultSuccess(result.data));
+              } else {
+                const { code, message } = result.data;
+                resolve(CommandResultFailure(code, message));
+              }
+            }
+          } catch (error) {
+            console.error(`XRPlatform cmd: ${cmd}, msg: ${msg} error: ${error}`);
+            const { code, message } = error;
+            resolve(CommandResultFailure(code, message));
+          }
+        });
+      }
+      async callWebSpatialProtocol(command, query, target, features) {
+        return new Promise((resolve, reject) => {
+          const createdId = nextRequestId();
+          try {
+            let windowProxy = null;
+            SpatialWebEvent.addEventReceiver(
+              createdId,
+              (result) => {
+                console.log("createdId", createdId, result.spatialId);
+                resolve(
+                  CommandResultSuccess({
+                    windowProxy,
+                    id: result.spatialId
+                  })
+                );
+                SpatialWebEvent.removeEventReceiver(createdId);
+              }
+            );
+            windowProxy = this.openWindow(
+              command,
+              query,
+              target,
+              features
+            ).windowProxy;
+            windowProxy?.open(`about:blank?rid=${createdId}`, "_self");
+          } catch (error) {
+            console.error(`open window error: ${error}`);
+            const { code, message } = error;
+            SpatialWebEvent.removeEventReceiver(createdId);
+            resolve(CommandResultFailure(code, message));
+          }
+        });
+      }
+      callWebSpatialProtocolSync(command, query, target, features) {
+        const { spatialId: id = "", windowProxy } = this.openWindow(
+          command,
+          query,
+          target,
+          features
+        );
+        return CommandResultSuccess({ windowProxy, id });
+      }
+      openWindow(command, query, target, features) {
+        const windowProxy = window.open(
+          `webspatial://${command}?${query || ""}`,
+          target,
+          features
+        );
+        return { spatialId: "", windowProxy };
+      }
+    };
+  }
+});
+
 // src/platform-adapter/android/AndroidPlatform.ts
 var AndroidPlatform_exports = {};
 __export(AndroidPlatform_exports, {
   AndroidPlatform: () => AndroidPlatform
 });
-function nextRequestId() {
-  requestId = (requestId + 1) % MAX_ID;
-  return `rId_${requestId}`;
+function nextRequestId2() {
+  requestId2 = (requestId2 + 1) % MAX_ID2;
+  return `rId_${requestId2}`;
 }
-var creatingElementCount, requestId, MAX_ID, AndroidPlatform;
+var creatingElementCount, requestId2, MAX_ID2, AndroidPlatform;
 var init_AndroidPlatform = __esm({
   "src/platform-adapter/android/AndroidPlatform.ts"() {
     "use strict";
@@ -132,13 +235,13 @@ var init_AndroidPlatform = __esm({
     init_JSBCommand();
     init_SpatialWebEvent();
     creatingElementCount = 0;
-    requestId = 0;
-    MAX_ID = 1e5;
+    requestId2 = 0;
+    MAX_ID2 = 1e5;
     AndroidPlatform = class {
       async callJSB(cmd, msg) {
         return new Promise((resolve, reject) => {
           try {
-            const rId = nextRequestId();
+            const rId = nextRequestId2();
             SpatialWebEvent.addEventReceiver(rId, (result) => {
               SpatialWebEvent.removeEventReceiver(rId);
               if (result.success) {
@@ -181,10 +284,10 @@ var init_AndroidPlatform = __esm({
           await new Promise((resolve) => setTimeout(resolve, 16));
         }
         windowProxy?.open("about:blank", "_self");
-        while (!windowProxy?.SpatialId) {
+        while (!windowProxy?.__SpatialId) {
           await new Promise((resolve) => setTimeout(resolve, 16));
         }
-        let spatialId = windowProxy?.SpatialId;
+        let spatialId = windowProxy?.__SpatialId;
         creatingElementCount--;
         return Promise.resolve(
           CommandResultSuccess({ windowProxy, id: spatialId })
@@ -270,11 +373,38 @@ var init_VisionOSPlatform = __esm({
 });
 
 // src/platform-adapter/index.ts
+function getWebSpatialVersion(ua) {
+  const match = ua.match(/WebSpatial\/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) {
+    return null;
+  }
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function isVersionGreater(a, b) {
+  if (!a) {
+    return false;
+  }
+  for (let index = 0; index < 3; index += 1) {
+    const diff = a[index] - b[index];
+    if (diff > 0) {
+      return true;
+    }
+    if (diff < 0) {
+      return false;
+    }
+  }
+  return false;
+}
 function createPlatform() {
   if (isSSREnv()) {
     return new SSRPlatform();
   }
-  if (window.navigator.userAgent.includes("Android") || window.navigator.userAgent.includes("Linux")) {
+  const userAgent = window.navigator.userAgent;
+  const webSpatialVersion = getWebSpatialVersion(userAgent);
+  if (userAgent.includes("PicoWebApp") && isVersionGreater(webSpatialVersion, [0, 0, 1])) {
+    const XRPlatform2 = (init_XRPlatform(), __toCommonJS(XRPlatform_exports)).XRPlatform;
+    return new XRPlatform2();
+  } else if (userAgent.includes("Android") || userAgent.includes("Linux")) {
     const AndroidPlatform2 = (init_AndroidPlatform(), __toCommonJS(AndroidPlatform_exports)).AndroidPlatform;
     return new AndroidPlatform2();
   } else {
@@ -997,14 +1127,29 @@ var SceneManager = class _SceneManager {
     if (name === void 0 || !this.configMap[name]) return void 0;
     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>)
+  ensureAbsoluteUrl(raw) {
+    if (!raw) return raw;
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(raw)) {
+      return raw;
+    }
+    if (raw.startsWith("//")) {
+      return `${window.location.protocol}${raw}`;
+    }
+    try {
+      return new URL(raw, document.baseURI).toString();
+    } catch {
+      return raw;
+    }
+  }
   open = (url, target, features) => {
     if (url?.startsWith(INTERNAL_SCHEMA_PREFIX)) {
       return this.originalOpen(url, target, features);
     }
-    const prefix = `${window.location.protocol}//${window.location.host}`;
-    if (!url?.startsWith(prefix)) {
-      url = prefix + url;
-    }
+    url = this.ensureAbsoluteUrl(url);
     if (target === "_self" || target === "_parent" || target === "_top") {
       const newWindow = this.originalOpen(url, target, features);
       return newWindow;
@@ -1012,9 +1157,6 @@ var SceneManager = class _SceneManager {
     const cfg = target ? this.getConfig(target) : void 0;
     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) {
       let focusCmd = new FocusScene(id);
@@ -1338,64 +1480,43 @@ var SpatializedElement = class extends SpatialObject {
         data.detail
       );
       this._onSpatialTap?.(event);
+    } else if (type === "spatialdragstart" /* spatialdragstart */) {
+      const dragStartEvent = createSpatialEvent(
+        "spatialdragstart" /* spatialdragstart */,
+        data.detail
+      );
+      this._onSpatialDragStart?.(dragStartEvent);
     } else if (type === "spatialdrag" /* spatialdrag */) {
-      if (!this._isDragging) {
-        const dragStartEvent = createSpatialEvent(
-          "spatialdragstart" /* spatialdragstart */,
-          data.detail
-        );
-        this._onSpatialDragStart?.(dragStartEvent);
-      }
-      this._isDragging = true;
       const event = createSpatialEvent(
         "spatialdrag" /* spatialdrag */,
         data.detail
       );
       this._onSpatialDrag?.(event);
     } else if (type === "spatialdragend" /* spatialdragend */) {
-      this._isDragging = false;
       const event = createSpatialEvent(
         "spatialdragend" /* spatialdragend */,
         data.detail
       );
       this._onSpatialDragEnd?.(event);
     } else if (type === "spatialrotate" /* spatialrotate */) {
-      if (!this._isRotating) {
-        const rotationStartEvent = createSpatialEvent(
-          "spatialrotatestart" /* spatialrotatestart */,
-          data.detail
-        );
-        this._onSpatialRotateStart?.(rotationStartEvent);
-      }
-      this._isRotating = true;
       const event = createSpatialEvent(
         "spatialrotate" /* spatialrotate */,
         data.detail
       );
       this._onSpatialRotate?.(event);
     } else if (type === "spatialrotateend" /* spatialrotateend */) {
-      this._isRotating = false;
       const event = createSpatialEvent(
         "spatialrotateend" /* spatialrotateend */,
         data.detail
       );
       this._onSpatialRotateEnd?.(event);
     } else if (type === "spatialmagnify" /* spatialmagnify */) {
-      if (!this._isMagnify) {
-        const magnifyStartEvent = createSpatialEvent(
-          "spatialmagnifystart" /* spatialmagnifystart */,
-          data.detail
-        );
-        this._onSpatialMagnifyStart?.(magnifyStartEvent);
-      }
-      this._isMagnify = true;
       const event = createSpatialEvent(
         "spatialmagnify" /* spatialmagnify */,
         data.detail
       );
       this._onSpatialMagnify?.(event);
     } else if (type === "spatialmagnifyend" /* spatialmagnifyend */) {
-      this._isMagnify = false;
       const event = createSpatialEvent(
         "spatialmagnifyend" /* spatialmagnifyend */,
         data.detail
@@ -1410,7 +1531,6 @@ var SpatializedElement = class extends SpatialObject {
       enableTapGesture: value !== void 0
     });
   }
-  _isDragging = false;
   _onSpatialDragStart;
   set onSpatialDragStart(value) {
     this._onSpatialDragStart = value;
@@ -1432,14 +1552,6 @@ var SpatializedElement = class extends SpatialObject {
       enableDragEndGesture: value !== void 0
     });
   }
-  _isRotating = false;
-  _onSpatialRotateStart;
-  set onSpatialRotateStart(value) {
-    this._onSpatialRotateStart = value;
-    this.updateProperties({
-      enableRotateStartGesture: this._onSpatialRotateStart !== void 0
-    });
-  }
   _onSpatialRotate;
   set onSpatialRotate(value) {
     this._onSpatialRotate = value;
@@ -1454,14 +1566,6 @@ var SpatializedElement = class extends SpatialObject {
       enableRotateEndGesture: value !== void 0
     });
   }
-  _isMagnify = false;
-  _onSpatialMagnifyStart;
-  set onSpatialMagnifyStart(value) {
-    this._onSpatialMagnifyStart = value;
-    this.updateProperties({
-      enableMagnifyStartGesture: value !== void 0
-    });
-  }
   _onSpatialMagnify;
   set onSpatialMagnify(value) {
     this._onSpatialMagnify = value;
@@ -1772,12 +1876,6 @@ var SpatialEntity = class _SpatialEntity extends SpatialObject {
         data.detail
       );
       this.dispatchEvent(evt);
-    } else if (type === "spatialrotatestart" /* spatialrotatestart */) {
-      const evt = createSpatialEvent(
-        "spatialrotatestart" /* spatialrotatestart */,
-        data.detail
-      );
-      this.dispatchEvent(evt);
     } else if (type === "spatialrotate" /* spatialrotate */) {
       const evt = createSpatialEvent(
         "spatialrotate" /* spatialrotate */,
@@ -1790,12 +1888,6 @@ var SpatialEntity = class _SpatialEntity extends SpatialObject {
         data.detail
       );
       this.dispatchEvent(evt);
-    } else if (type === "spatialmagnifystart" /* spatialmagnifystart */) {
-      const evt = createSpatialEvent(
-        "spatialmagnifystart" /* spatialmagnifystart */,
-        data.detail
-      );
-      this.dispatchEvent(evt);
     } else if (type === "spatialmagnify" /* spatialmagnify */) {
       const evt = createSpatialEvent(
         "spatialmagnify" /* spatialmagnify */,
@@ -1811,6 +1903,9 @@ var SpatialEntity = class _SpatialEntity extends SpatialObject {
     }
   };
   dispatchEvent(evt) {
+    if (!evt.__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) {
@@ -2217,7 +2312,7 @@ var Spatial = class {
    * @returns Client SDK version string in format "x.x.x"
    */
   getClientVersion() {
-    return "1.0.5";
+    return "1.2.0";
   }
 };