@webspatial/core-sdk 0.0.1

package/dist/core/SpatialSession.d.ts

@@ -0,0 +1,166 @@
+import { SpatialEntity } from './SpatialEntity';
+import { SpatialWindowContainer } from './SpatialWindowContainer';
+import { LoadingMethodKind, sceneDataShape, WindowStyle } from './types';
+import { SpatialMeshResource, SpatialPhysicallyBasedMaterialResource } from './resource';
+import { SpatialModelComponent, SpatialInputComponent, SpatialWindowComponent, SpatialViewComponent, SpatialModel3DComponent } from './component';
+/**
+ * Animation callback with timestamp
+ */
+type animCallback = (time: DOMHighResTimeStamp) => Promise<any>;
+/**
+ * Session use to establish a connection to the spatial renderer of the system. All resources must be created by the session
+ */
+export declare class SpatialSession {
+    /** @hidden */
+    _engineUpdateListeners: animCallback[];
+    /** @hidden */
+    _frameLoopStarted: boolean;
+    /**
+     * Add event listener callback to be called each frame
+     * @param callback callback to be called each update
+     */
+    addOnEngineUpdateEventListener(callback: animCallback): void;
+    /**
+     * Creates a Entity
+     * @returns Entity
+     */
+    createEntity(): Promise<SpatialEntity>;
+    /**
+     * Creates a WindowComponent
+     * [TODO] should creation of components be moved to entity? and these made private?
+     * @returns WindowComponent
+     */
+    createWindowComponent(options?: {
+        windowContainer?: SpatialWindowContainer;
+    }): Promise<SpatialWindowComponent>;
+    /**
+     * Creates a ViewComponent used to display 3D content within the entity
+     * @returns SpatialViewComponent
+     */
+    createViewComponent(options?: {
+        windowContainer?: SpatialWindowContainer;
+    }): Promise<SpatialViewComponent>;
+    /**
+     * Creates a ModelComponent used to display geometry + material of a 3D model
+     * @returns ModelComponent
+     */
+    createModelComponent(options?: {
+        url: string;
+    }): Promise<SpatialModelComponent>;
+    /**
+     * Creates a Model3DComponent
+     * @returns Model3DComponent
+     */
+    createModel3DComponent(options?: {
+        url: string;
+    }): Promise<SpatialModel3DComponent>;
+    /**
+     * Creates a InputComponent
+     * [Experimental] Creates a InputComponent used to handle click and drag events of the entity containing a model
+     * @returns InputComponent
+     */
+    createInputComponent(): Promise<SpatialInputComponent>;
+    /**
+     * Creates a MeshResource containing geometry data
+     * @returns MeshResource
+     */
+    createMeshResource(options?: {
+        shape?: string;
+    }): Promise<SpatialMeshResource>;
+    /**
+     * Creates a PhysicallyBasedMaterial containing PBR material data
+     * @returns PhysicallyBasedMaterial
+     */
+    createPhysicallyBasedMaterialResource(options?: {}): Promise<SpatialPhysicallyBasedMaterialResource>;
+    /**
+     * Creates a WindowContainer
+     * @returns SpatialWindowContainer
+     * */
+    createWindowContainer(options?: {
+        style: WindowStyle;
+        windowContainer?: SpatialWindowContainer | null;
+        windowComponent?: SpatialWindowComponent | null;
+    }): Promise<SpatialWindowContainer>;
+    /**
+     * Creates a Scene to display content within an anchored area managed by the OS
+     * @hidden
+     * @param {WindowStyle} [style='Plain'] - The style of the Scene container to be created with. Defaults to 'Plain'.
+     * @param {Object} [cfg={}] - Configuration object for the Scene.
+     * @returns Boolean
+     */
+    _createScene(style: WindowStyle | undefined, cfg: {
+        sceneData: sceneDataShape;
+    }): Promise<boolean>;
+    /**
+     * Retrieves the window for this page
+     * @returns the window component corresponding to the js running on this page
+     * [TODO] discuss implications of this not being async
+     */
+    getCurrentWindowComponent(): SpatialWindowComponent;
+    /**
+     * Retrieves the parent window for this page or null if this is the root page
+     * @returns the window component or null
+     */
+    getParentWindowComponent(): Promise<SpatialWindowComponent | null>;
+    /**
+     * Logs a message to the native apps console
+     * @param msg mesage to log
+     */
+    log(...msg: any[]): Promise<void>;
+    /**
+     * @hidden
+     * Debugging only, used to ping the native renderer
+     */
+    _ping(msg: string): Promise<unknown>;
+    /**
+     * @hidden
+     * Debugging to get internal state from native code
+     * @returns data as a js object
+     */
+    _getStats(): Promise<{
+        objects: any;
+        refObjects: any;
+    }>;
+    /**
+     * @hidden
+     */
+    _inspect(spatialObjectId?: string): Promise<any>;
+    /**
+     * @hidden
+     */
+    _inspectRootWindowContainer(): Promise<any>;
+    /** Opens the immersive space */
+    openImmersiveSpace(): Promise<void>;
+    /** Closes the immersive space */
+    dismissImmersiveSpace(): Promise<void>;
+    private static _immersiveWindowContainer;
+    /**
+     * Retreives the window container corresponding to the Immersive space
+     * @returns the immersive window container
+     */
+    getImmersiveWindowContainer(): Promise<SpatialWindowContainer>;
+    private static _currentWindowContainer;
+    /**
+     * Gets the current window container for the window
+     * [TODO] discuss what happens if it doesnt yet have a window container
+     * @returns the current window container for the window
+     */
+    getCurrentWindowContainer(): SpatialWindowContainer;
+    /**
+     * Start a transaction that queues up commands to submit them all at once to reduce ipc overhead
+     * @param fn function to be run, within this function, promises will not resolve
+     * @returns promise for the entire transaction completion
+     */
+    transaction(fn: Function): Promise<unknown>;
+    /**
+     * Creates a window context object that is compatable with SpatialWindowComponent's setFromWindow API
+     * @returns window context
+     */
+    createWindowContext(): Promise<Window | null>;
+    /** @hidden */
+    _getEntity(id: string): Promise<SpatialEntity>;
+    /** @hidden */
+    setLoading(method: LoadingMethodKind, style?: string): Promise<unknown>;
+}
+export {};
+//# sourceMappingURL=SpatialSession.d.ts.map

package/dist/core/SpatialSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialSession.d.ts","sourceRoot":"","sources":["../../src/core/SpatialSession.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAA;AAMjE,OAAO,EACL,iBAAiB,EACjB,cAAc,EAEd,WAAW,EACZ,MAAM,SAAS,CAAA;AAEhB,OAAO,EACL,mBAAmB,EACnB,sCAAsC,EACvC,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,uBAAuB,EACxB,MAAM,aAAa,CAAA;AAGpB;;GAEG;AACH,KAAK,YAAY,GAAG,CAAC,IAAI,EAAE,mBAAmB,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;AA4B/D;;GAEG;AACH,qBAAa,cAAc;IACzB,cAAc;IACd,sBAAsB,iBAAwB;IAC9C,cAAc;IACd,iBAAiB,UAAQ;IAEzB;;;OAGG;IACH,8BAA8B,CAAC,QAAQ,EAAE,YAAY;IAerD;;;OAGG;IACG,YAAY;IASlB;;;;OAIG;IACG,qBAAqB,CAAC,OAAO,CAAC,EAAE;QACpC,eAAe,CAAC,EAAE,sBAAsB,CAAA;KACzC;IAWD;;;OAGG;IACG,mBAAmB,CAAC,OAAO,CAAC,EAAE;QAClC,eAAe,CAAC,EAAE,sBAAsB,CAAA;KACzC;IAWD;;;OAGG;IACG,oBAAoB,CAAC,OAAO,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE;IAcpD;;;OAGG;IACG,sBAAsB,CAAC,OAAO,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE;IActD;;;;OAIG;IACG,oBAAoB;IAS1B;;;OAGG;IACG,kBAAkB,CAAC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;IAUrD;;;OAGG;IACG,qCAAqC,CAAC,OAAO,CAAC,EAAE,EAAE;IASxD;;;SAGK;IACC,qBAAqB,CAAC,OAAO,CAAC,EAAE;QACpC,KAAK,EAAE,WAAW,CAAA;QAClB,eAAe,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAA;QAC/C,eAAe,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAChD;IAYD;;;;;;OAMG;IACG,YAAY,CAChB,KAAK,EAAE,WAAW,YAAU,EAC5B,GAAG,EAAE;QACH,SAAS,EAAE,cAAc,CAAA;KAC1B;IAKH;;;;OAIG;IACH,yBAAyB;IAIzB;;;OAGG;IACG,wBAAwB;IAgB9B;;;OAGG;IACG,GAAG,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE;IAIvB;;;OAGG;IACG,KAAK,CAAC,GAAG,EAAE,MAAM;IAIvB;;;;OAIG;IACG,SAAS;iBACsC,GAAG;oBAAc,GAAG;;IAGzE;;OAEG;IACG,QAAQ,CAAC,eAAe,GAAE,MAA2C;IAI3E;;OAEG;IACG,2BAA2B;IAIjC,gCAAgC;IAC1B,kBAAkB;IAIxB,iCAAiC;IAC3B,qBAAqB;IAI3B,OAAO,CAAC,MAAM,CAAC,yBAAyB,CACD;IACvC;;;OAGG;IACG,2BAA2B;IAYjC,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAAwC;IAE9E;;;;OAIG;IACH,yBAAyB;IAWzB;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,QAAQ;IAMxB;;;OAGG;IACG,mBAAmB;IAgCzB,cAAc;IACR,UAAU,CAAC,EAAE,EAAE,MAAM;IAoB3B,cAAc;IACR,UAAU,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE,MAAM;CAG3D"}

package/dist/core/SpatialSession.js

@@ -0,0 +1,310 @@
+import { SpatialEntity } from './SpatialEntity';
+import { SpatialWindowContainer } from './SpatialWindowContainer';
+import { WebSpatial, WebSpatialResource, } from './private/WebSpatial';
+import { SpatialMeshResource, SpatialPhysicallyBasedMaterialResource, } from './resource';
+import { SpatialModelComponent, SpatialInputComponent, SpatialWindowComponent, SpatialViewComponent, SpatialModel3DComponent, } from './component';
+import { RemoteCommand } from './private/remote-command';
+/**
+ * Parses the resource owners of the created object. If unedfined, will use the current window container and web panel. If null the created resource will not be destroyed unless explicitly destroyed.
+ * @param options
+ * @returns parsed results
+ */
+function _parseParentResources(options) {
+    var parentWindowContainer = null;
+    if (options?.windowContainer !== null) {
+        parentWindowContainer = options?.windowContainer
+            ? options?.windowContainer._wg
+            : WebSpatial.getCurrentWindowContainer();
+    }
+    var parentWindow = null;
+    if (options?.windowComponent !== null) {
+        parentWindow = options?.windowComponent
+            ? options?.windowComponent._resource
+            : WebSpatial.getCurrentWebPanel();
+    }
+    return [parentWindowContainer, parentWindow];
+}
+/**
+ * Session use to establish a connection to the spatial renderer of the system. All resources must be created by the session
+ */
+export class SpatialSession {
+    /** @hidden */
+    _engineUpdateListeners = Array();
+    /** @hidden */
+    _frameLoopStarted = false;
+    /**
+     * Add event listener callback to be called each frame
+     * @param callback callback to be called each update
+     */
+    addOnEngineUpdateEventListener(callback) {
+        this._engineUpdateListeners.push(callback);
+        if (!this._frameLoopStarted) {
+            this._frameLoopStarted = true;
+            WebSpatial.onFrame(async (time) => {
+                await Promise.all(this._engineUpdateListeners.map(cb => {
+                    return cb(time);
+                }));
+            });
+        }
+    }
+    /**
+     * Creates a Entity
+     * @returns Entity
+     */
+    async createEntity() {
+        let entity = await WebSpatial.createResource('Entity', WebSpatial.getCurrentWindowContainer(), WebSpatial.getCurrentWebPanel());
+        return new SpatialEntity(entity);
+    }
+    /**
+     * Creates a WindowComponent
+     * [TODO] should creation of components be moved to entity? and these made private?
+     * @returns WindowComponent
+     */
+    async createWindowComponent(options) {
+        let entity = await WebSpatial.createResource('SpatialWebView', options?.windowContainer
+            ? options?.windowContainer._wg
+            : WebSpatial.getCurrentWindowContainer(), WebSpatial.getCurrentWebPanel());
+        return new SpatialWindowComponent(entity);
+    }
+    /**
+     * Creates a ViewComponent used to display 3D content within the entity
+     * @returns SpatialViewComponent
+     */
+    async createViewComponent(options) {
+        let entity = await WebSpatial.createResource('SpatialView', options?.windowContainer
+            ? options?.windowContainer._wg
+            : WebSpatial.getCurrentWindowContainer(), WebSpatial.getCurrentWebPanel());
+        return new SpatialViewComponent(entity);
+    }
+    /**
+     * Creates a ModelComponent used to display geometry + material of a 3D model
+     * @returns ModelComponent
+     */
+    async createModelComponent(options) {
+        var opts = undefined;
+        if (options) {
+            opts = { modelURL: options.url };
+        }
+        let entity = await WebSpatial.createResource('ModelComponent', WebSpatial.getCurrentWindowContainer(), WebSpatial.getCurrentWebPanel(), opts);
+        return new SpatialModelComponent(entity);
+    }
+    /**
+     * Creates a Model3DComponent
+     * @returns Model3DComponent
+     */
+    async createModel3DComponent(options) {
+        var opts = undefined;
+        if (options) {
+            opts = { modelURL: options.url };
+        }
+        let entity = await WebSpatial.createResource('Model3DComponent', WebSpatial.getCurrentWindowContainer(), WebSpatial.getCurrentWebPanel(), opts);
+        return new SpatialModel3DComponent(entity);
+    }
+    /**
+     * Creates a InputComponent
+     * [Experimental] Creates a InputComponent used to handle click and drag events of the entity containing a model
+     * @returns InputComponent
+     */
+    async createInputComponent() {
+        let entity = await WebSpatial.createResource('InputComponent', WebSpatial.getCurrentWindowContainer(), WebSpatial.getCurrentWebPanel());
+        return new SpatialInputComponent(entity);
+    }
+    /**
+     * Creates a MeshResource containing geometry data
+     * @returns MeshResource
+     */
+    async createMeshResource(options) {
+        let entity = await WebSpatial.createResource('MeshResource', WebSpatial.getCurrentWindowContainer(), WebSpatial.getCurrentWebPanel(), options);
+        return new SpatialMeshResource(entity);
+    }
+    /**
+     * Creates a PhysicallyBasedMaterial containing PBR material data
+     * @returns PhysicallyBasedMaterial
+     */
+    async createPhysicallyBasedMaterialResource(options) {
+        let entity = await WebSpatial.createResource('PhysicallyBasedMaterial', WebSpatial.getCurrentWindowContainer(), WebSpatial.getCurrentWebPanel(), options);
+        return new SpatialPhysicallyBasedMaterialResource(entity);
+    }
+    /**
+     * Creates a WindowContainer
+     * @returns SpatialWindowContainer
+     * */
+    async createWindowContainer(options) {
+        var style = options?.style ? options?.style : 'Plain';
+        var [parentWindowContainer, parentWindow] = _parseParentResources(options);
+        return new SpatialWindowContainer(await WebSpatial.createWindowContainer(style, parentWindowContainer, parentWindow));
+    }
+    /**
+     * Creates a Scene to display content within an anchored area managed by the OS
+     * @hidden
+     * @param {WindowStyle} [style='Plain'] - The style of the Scene container to be created with. Defaults to 'Plain'.
+     * @param {Object} [cfg={}] - Configuration object for the Scene.
+     * @returns Boolean
+     */
+    async _createScene(style = 'Plain', cfg) {
+        return await WebSpatial.createScene(style, cfg);
+    }
+    /**
+     * Retrieves the window for this page
+     * @returns the window component corresponding to the js running on this page
+     * [TODO] discuss implications of this not being async
+     */
+    getCurrentWindowComponent() {
+        return new SpatialWindowComponent(WebSpatial.getCurrentWebPanel());
+    }
+    /**
+     * Retrieves the parent window for this page or null if this is the root page
+     * @returns the window component or null
+     */
+    async getParentWindowComponent() {
+        let parentResp = await WebSpatial.updateResource(WebSpatial.getCurrentWebPanel(), { getParentID: '' });
+        if (parentResp.data.parentID === '') {
+            return new Promise((res, rej) => {
+                res(null);
+            });
+        }
+        else {
+            var res = new WebSpatialResource();
+            res.id = parentResp.data.parentID;
+            return new SpatialWindowComponent(res);
+        }
+    }
+    /**
+     * Logs a message to the native apps console
+     * @param msg mesage to log
+     */
+    async log(...msg) {
+        await WebSpatial.sendCommand(new RemoteCommand('log', { logString: msg }));
+    }
+    /**
+     * @hidden
+     * Debugging only, used to ping the native renderer
+     */
+    async _ping(msg) {
+        return await WebSpatial.ping(msg);
+    }
+    /**
+     * @hidden
+     * Debugging to get internal state from native code
+     * @returns data as a js object
+     */
+    async _getStats() {
+        return (await WebSpatial.getStats());
+    }
+    /**
+     * @hidden
+     */
+    async _inspect(spatialObjectId = WebSpatial.getCurrentWebPanel().id) {
+        return WebSpatial.inspect(spatialObjectId);
+    }
+    /**
+     * @hidden
+     */
+    async _inspectRootWindowContainer() {
+        return WebSpatial.inspectRootWindowContainer();
+    }
+    /** Opens the immersive space */
+    async openImmersiveSpace() {
+        return await WebSpatial.openImmersiveSpace();
+    }
+    /** Closes the immersive space */
+    async dismissImmersiveSpace() {
+        return await WebSpatial.dismissImmersiveSpace();
+    }
+    static _immersiveWindowContainer = null;
+    /**
+     * Retreives the window container corresponding to the Immersive space
+     * @returns the immersive window container
+     */
+    async getImmersiveWindowContainer() {
+        if (SpatialSession._immersiveWindowContainer) {
+            return SpatialSession._immersiveWindowContainer;
+        }
+        else {
+            SpatialSession._immersiveWindowContainer = new SpatialWindowContainer(WebSpatial.getImmersiveWindowContainer());
+            return SpatialSession._immersiveWindowContainer;
+        }
+    }
+    // Retreives the window container that is the parent to this spatial web page
+    static _currentWindowContainer = null;
+    /**
+     * Gets the current window container for the window
+     * [TODO] discuss what happens if it doesnt yet have a window container
+     * @returns the current window container for the window
+     */
+    getCurrentWindowContainer() {
+        if (SpatialSession._currentWindowContainer) {
+            return SpatialSession._currentWindowContainer;
+        }
+        else {
+            SpatialSession._currentWindowContainer = new SpatialWindowContainer(WebSpatial.getCurrentWindowContainer());
+            return SpatialSession._currentWindowContainer;
+        }
+    }
+    /**
+     * Start a transaction that queues up commands to submit them all at once to reduce ipc overhead
+     * @param fn function to be run, within this function, promises will not resolve
+     * @returns promise for the entire transaction completion
+     */
+    transaction(fn) {
+        WebSpatial.startTransaction();
+        fn();
+        return WebSpatial.sendTransaction();
+    }
+    /**
+     * Creates a window context object that is compatable with SpatialWindowComponent's setFromWindow API
+     * @returns window context
+     */
+    async createWindowContext() {
+        let openedWindow = window.open('webspatial://createWindowContext');
+        if (WebSpatial.getBackend() != 'AVP') {
+            // Currently there is a bug with webview which requires us to trigger a navigation before native code can interact with created webview
+            var counter = 0;
+            while (openedWindow.window.testAPI == null) {
+                if (counter > 15) {
+                    openedWindow?.close();
+                    openedWindow = window.open('about:blank');
+                    counter = 0;
+                    this.log('unexpected error when trying to open new window, retrying.');
+                }
+                var locName = 'about:blank?x' + counter;
+                openedWindow.location.href = locName;
+                counter++;
+                await new Promise(resolve => setTimeout(resolve, 10));
+            }
+            ;
+            openedWindow._webSpatialID = openedWindow.window.testAPI.getWindowID();
+        }
+        else {
+            while (openedWindow.window._webSpatialID == undefined) {
+                await new Promise(resolve => setTimeout(resolve, 10));
+            }
+        }
+        openedWindow.document.head.innerHTML =
+            '<meta name="viewport" content="width=device-width, initial-scale=1">';
+        return openedWindow;
+    }
+    // Get Entity by id. Currently for debugging only.
+    /** @hidden */
+    async _getEntity(id) {
+        const entityInfo = await WebSpatial.inspect(id);
+        const [_, x, y, z] = entityInfo.position.match(/(\d+\.?\d*)/g);
+        const [__, sx, sy, sz] = entityInfo.scale.match(/(\d+\.?\d*)/g);
+        var res = new WebSpatialResource();
+        res.id = id;
+        res.windowContainerId = WebSpatial.getCurrentWindowContainer().id;
+        const entity = new SpatialEntity(res);
+        entity.transform.position.x = parseFloat(x);
+        entity.transform.position.y = parseFloat(y);
+        entity.transform.position.z = parseFloat(z);
+        entity.transform.scale.x = parseFloat(sx);
+        entity.transform.scale.y = parseFloat(sy);
+        entity.transform.scale.z = parseFloat(sz);
+        return entity;
+    }
+    // set loading view.
+    /** @hidden */
+    async setLoading(method, style) {
+        return WebSpatial.setLoading(method, style);
+    }
+}

package/dist/core/SpatialTransform.d.ts

@@ -0,0 +1,23 @@
+export declare class Vec3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number, y?: number, z?: number);
+}
+export declare class Vec4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+}
+/**
+ * Transform containing position, orientation and scale
+ */
+export declare class SpatialTransform {
+    position: Vec3;
+    /** Quaternion value for x,y,z,w */
+    orientation: Vec4;
+    scale: Vec3;
+}
+//# sourceMappingURL=SpatialTransform.d.ts.map

package/dist/core/SpatialTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialTransform.d.ts","sourceRoot":"","sources":["../../src/core/SpatialTransform.ts"],"names":[],"mappings":"AAAA,qBAAa,IAAI;IAEN,CAAC;IACD,CAAC;IACD,CAAC;gBAFD,CAAC,SAAI,EACL,CAAC,SAAI,EACL,CAAC,SAAI;CAEf;AAED,qBAAa,IAAI;IAEN,CAAC;IACD,CAAC;IACD,CAAC;IACD,CAAC;gBAHD,CAAC,SAAI,EACL,CAAC,SAAI,EACL,CAAC,SAAI,EACL,CAAC,SAAI;CAEf;AAED;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,QAAQ,OAAoB;IAC5B,mCAAmC;IACnC,WAAW,OAAuB;IAClC,KAAK,OAAoB;CAC1B"}

package/dist/core/SpatialTransform.js

@@ -0,0 +1,31 @@
+export class Vec3 {
+    x;
+    y;
+    z;
+    constructor(x = 0, y = 0, z = 0) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+}
+export class Vec4 {
+    x;
+    y;
+    z;
+    w;
+    constructor(x = 0, y = 0, z = 0, w = 1) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+    }
+}
+/**
+ * Transform containing position, orientation and scale
+ */
+export class SpatialTransform {
+    position = new Vec3(0, 0, 0);
+    /** Quaternion value for x,y,z,w */
+    orientation = new Vec4(0, 0, 0, 1);
+    scale = new Vec3(1, 1, 1);
+}

package/dist/core/SpatialWindowContainer.d.ts

@@ -0,0 +1,31 @@
+import { WindowContainer } from './private/WebSpatial';
+import { SpatialEntity } from './SpatialEntity';
+/**
+ * Anchored window managed by the OS
+ */
+export declare class SpatialWindowContainer {
+    /** @hidden */
+    _wg: WindowContainer;
+    /** @hidden */
+    constructor(
+    /** @hidden */
+    _wg: WindowContainer);
+    /**
+     * @hidden
+     * Sets sets the open configuration for opening new window containers
+     * @param options style options
+     */
+    _setOpenSettings(options: {
+        resolution: {
+            width: number;
+            height: number;
+        };
+    }): Promise<void>;
+    /**
+     * Retrieves the root entity of the windowContainer
+     * @returns the root entity of the windowContainer if one exists
+     */
+    getRootEntity(): Promise<SpatialEntity | null>;
+    setRootEntity(entity: SpatialEntity): Promise<void>;
+}
+//# sourceMappingURL=SpatialWindowContainer.d.ts.map

package/dist/core/SpatialWindowContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialWindowContainer.d.ts","sourceRoot":"","sources":["../../src/core/SpatialWindowContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,eAAe,EAChB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C;;GAEG;AACH,qBAAa,sBAAsB;IAG/B,cAAc;IACP,GAAG,EAAE,eAAe;IAH7B,cAAc;;IAEZ,cAAc;IACP,GAAG,EAAE,eAAe;IAE7B;;;;OAIG;IACG,gBAAgB,CAAC,OAAO,EAAE;QAAE,UAAU,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE;IAMjF;;;OAGG;IACG,aAAa;IAgBb,aAAa,CAAC,MAAM,EAAE,aAAa;CAG1C"}

package/dist/core/SpatialWindowContainer.js

@@ -0,0 +1,48 @@
+import { WebSpatial, WebSpatialResource, } from './private/WebSpatial';
+import { SpatialEntity } from './SpatialEntity';
+/**
+ * Anchored window managed by the OS
+ */
+export class SpatialWindowContainer {
+    _wg;
+    /** @hidden */
+    constructor(
+    /** @hidden */
+    _wg) {
+        this._wg = _wg;
+    }
+    /**
+     * @hidden
+     * Sets sets the open configuration for opening new window containers
+     * @param options style options
+     */
+    async _setOpenSettings(options) {
+        await WebSpatial.updateWindowContainer(this._wg, {
+            nextOpenSettings: options,
+        });
+    }
+    /**
+     * Retrieves the root entity of the windowContainer
+     * @returns the root entity of the windowContainer if one exists
+     */
+    async getRootEntity() {
+        let reqResp = await WebSpatial.updateWindowContainer(this._wg, {
+            getRootEntityID: '',
+        });
+        if (reqResp.data.rootEntId === '') {
+            return null;
+        }
+        else {
+            var res = new WebSpatialResource();
+            res.id = reqResp.data.rootEntId;
+            return new SpatialEntity(res);
+        }
+    }
+    /*
+     * Sets the root entity that this windowContainer will display (this does not effect resource ownership)
+     * @param entity to display
+     */
+    async setRootEntity(entity) {
+        await entity._setParentWindowContainer(this);
+    }
+}

package/dist/core/component/EventSpatialComponent.d.ts

@@ -0,0 +1,22 @@
+import { WebSpatialResource } from '../private/WebSpatial';
+import { SpatialComponent } from './SpatialComponent';
+/**
+ * @description
+ * Represents a spatial component that handles events related to spatial interactions.
+ * This class extends `SpatialComponent` and provides additional functionality for managing
+ * event-driven spatial behaviors.
+ *
+ * @hidden
+ * This class is intended for internal use and should not be exposed in the public API.
+ */
+export declare abstract class EventSpatialComponent extends SpatialComponent {
+    constructor(_resource: WebSpatialResource);
+    /**
+     * @description
+     * Abstract method to be implemented by subclasses. Called when a spatial event is received.
+     * @param data The data associated with the received event.
+     */
+    protected abstract onRecvEvent(data: any): void;
+    protected onDestroy(): Promise<void>;
+}
+//# sourceMappingURL=EventSpatialComponent.d.ts.map

package/dist/core/component/EventSpatialComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventSpatialComponent.d.ts","sourceRoot":"","sources":["../../../src/core/component/EventSpatialComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAErD;;;;;;;;GAQG;AACH,8BAAsB,qBAAsB,SAAQ,gBAAgB;gBAEtD,SAAS,EAAE,kBAAkB;IAOzC;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI;cAEtB,SAAS;CAGnC"}

package/dist/core/component/EventSpatialComponent.js

@@ -0,0 +1,23 @@
+import { WebSpatial } from '../private/WebSpatial';
+import { SpatialComponent } from './SpatialComponent';
+/**
+ * @description
+ * Represents a spatial component that handles events related to spatial interactions.
+ * This class extends `SpatialComponent` and provides additional functionality for managing
+ * event-driven spatial behaviors.
+ *
+ * @hidden
+ * This class is intended for internal use and should not be exposed in the public API.
+ */
+export class EventSpatialComponent extends SpatialComponent {
+    // Class implementation goes here
+    constructor(_resource) {
+        super(_resource);
+        WebSpatial.registerEventReceiver(_resource.id, (data) => {
+            this.onRecvEvent(data);
+        });
+    }
+    async onDestroy() {
+        WebSpatial.unregisterEventReceiver(this._resource.id);
+    }
+}