@threlte/xr 0.1.3 → 1.0.0-next.0

package/dist/components/ARButton.svelte

@@ -10,6 +10,7 @@
 ```
 -->
 <script>import XRButton from "./XRButton.svelte";
+let { ...props } = $props();
 </script>
 
 <XRButton
@@ -18,8 +19,6 @@
     requiredFeatures: ['plane-detection'],
     optionalFeatures: ['local-floor', 'bounded-floor', 'hand-tracking', 'layers', 'hit-test']
   }}
-  {...$$restProps}
+  {...props}
   mode="immersive-ar"
-  on:click
-  on:error
 />

package/dist/components/ARButton.svelte.d.ts

@@ -18,12 +18,6 @@ declare const __propDef: {
         }) | undefined;
     };
     events: {
-        click: CustomEvent<{
-            state: "blocked" | "unsupported" | "insecure" | "supported";
-            nativeEvent: MouseEvent;
-        }>;
-        error: CustomEvent<Error>;
-    } & {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};

package/dist/components/Controller.svelte

@@ -5,14 +5,9 @@
  
   context="module"
 >import { writable } from "svelte/store";
-import { T, createRawEventDispatcher } from "@threlte/core";
+import { T } from "@threlte/core";
 import { left as leftStore, right as rightStore } from "../hooks/useController";
-import {
-  isHandTracking,
-  pointerState,
-  teleportState,
-  controllerDispatchers
-} from "../internal/stores";
+import { isHandTracking, pointerState, teleportState, controllerEvents } from "../internal/stores";
 import PointerCursor from "./internal/PointerCursor.svelte";
 import ShortRay from "./internal/ShortRay.svelte";
 import ScenePortal from "./internal/ScenePortal.svelte";
@@ -24,28 +19,17 @@ const stores = {
 };
 </script>
 
-<script>export let left = void 0;
-export let right = void 0;
-export let hand = void 0;
-const dispatch = createRawEventDispatcher();
+<script>let { left, right, hand, ...props } = $props();
 const handedness = writable(left ? "left" : right ? "right" : hand);
-$:
-  handedness.set(left ? "left" : right ? "right" : hand);
-controllerDispatchers[$handedness].set(dispatch);
-$:
-  controllerDispatchers[$handedness].set(dispatch);
-$:
-  store = stores[$handedness];
-$:
-  grip = $store?.grip;
-$:
-  targetRay = $store?.targetRay;
-$:
-  model = $store?.model;
-$:
-  hasPointerControls = $pointerState[$handedness].enabled;
-$:
-  hasTeleportControls = $teleportState[$handedness].enabled;
+$effect.pre(() => handedness.set(left ? "left" : right ? "right" : hand));
+controllerEvents[$handedness].set(props.$$events);
+$effect.pre(() => controllerEvents[$handedness].set(props.$$events));
+let store = $derived(stores[$handedness]);
+let grip = $derived($store?.grip);
+let targetRay = $derived($store?.targetRay);
+let model = $derived($store?.model);
+let hasPointerControls = $derived($pointerState[$handedness].enabled);
+let hasTeleportControls = $derived($teleportState[$handedness].enabled);
 </script>
 
 {#if !$isHandTracking}

package/dist/components/Hand.svelte

@@ -1,8 +1,9 @@
 <script
  
   context="module"
->import { T, useThrelte, createRawEventDispatcher, useTask } from "@threlte/core";
-import { isHandTracking, handDispatchers } from "../internal/stores";
+>import { Group } from "three";
+import { T, useThrelte, useTask } from "@threlte/core";
+import { isHandTracking, handEvents } from "../internal/stores";
 import { left as leftStore, right as rightStore } from "../hooks/useHand";
 import ScenePortal from "./internal/ScenePortal.svelte";
 import { writable } from "svelte/store";
@@ -12,18 +13,13 @@ const stores = {
 };
 </script>
 
-<script>export let left = void 0;
-export let right = void 0;
-export let hand = void 0;
-const dispatch = createRawEventDispatcher();
+<script>let { left, right, hand, ...props } = $props();
 const { xr } = useThrelte().renderer;
 const space = xr.getReferenceSpace();
 const handedness = writable(left ? "left" : right ? "right" : hand);
-$:
-  handedness.set(left ? "left" : right ? "right" : hand);
-$:
-  handDispatchers[$handedness].set(dispatch);
-let children;
+$effect.pre(() => handedness.set(left ? "left" : right ? "right" : hand));
+$effect.pre(() => handEvents[$handedness].set(props.$$events));
+let children = new Group();
 const { start, stop } = useTask(
   () => {
     const frame = xr.getFrame();
@@ -39,18 +35,16 @@ const { start, stop } = useTask(
   },
   { autoStart: false }
 );
-$:
+$effect.pre(() => {
   if ($isHandTracking && ($$slots.wrist || $$slots.default) && inputSource) {
     start();
   } else {
     stop();
   }
-$:
-  store = stores[$handedness];
-$:
-  inputSource = $store?.inputSource;
-$:
-  model = $store?.model;
+});
+let store = $derived(stores[$handedness]);
+let inputSource = $derived($store?.inputSource);
+let model = $derived($store?.model);
 </script>
 
 {#if $store?.hand && $isHandTracking}
@@ -69,9 +63,9 @@ $:
 
 {#if $isHandTracking}
   <ScenePortal>
-    <T.Group bind:ref={children}>
+    <T is={children}>
       <slot name="wrist" />
       <slot />
-    </T.Group>
+    </T>
   </ScenePortal>
 {/if}

package/dist/components/Hand.svelte.d.ts

@@ -1,7 +1,7 @@
 import { SvelteComponent } from "svelte";
 import type { XRHandEvent } from '../types';
 declare const __propDef: {
-    props: {
+    props: ({
         /** Whether the XRHand should be matched with the left hand. */
         left: true;
         right?: undefined;
@@ -16,6 +16,13 @@ declare const __propDef: {
         hand: 'left' | 'right';
         left?: undefined;
         right?: undefined;
+    }) & {
+        $$events: {
+            connected: XRHandEvent<'connected'>;
+            disconnected: XRHandEvent<'disconnected'>;
+            pinchstart: XRHandEvent<'pinchstart'>;
+            pinchend: XRHandEvent<'pinchend'>;
+        };
     };
     slots: {
         'target-ray': {};

package/dist/components/VRButton.svelte

@@ -10,14 +10,13 @@
 ```
 -->
 <script>import XRButton from "./XRButton.svelte";
+let { ...props } = $props();
 </script>
 
 <XRButton
   sessionInit={{
     optionalFeatures: ['local-floor', 'bounded-floor', 'hand-tracking', 'layers']
   }}
-  {...$$restProps}
+  {...props}
   mode="immersive-vr"
-  on:click
-  on:error
 />

package/dist/components/VRButton.svelte.d.ts

@@ -12,12 +12,6 @@ declare const __propDef: {
         styled?: boolean | undefined;
     }, "mode" | "sessionInit">;
     events: {
-        click: CustomEvent<{
-            state: "blocked" | "unsupported" | "insecure" | "supported";
-            nativeEvent: MouseEvent;
-        }>;
-        error: CustomEvent<Error>;
-    } & {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};

package/dist/components/XR.svelte

@@ -30,10 +30,12 @@ import { setupRaf } from "../internal/setupRaf";
 import { setupHeadset } from "../internal/setupHeadset";
 import { setupControllers } from "../internal/setupControllers";
 import { setupHands } from "../internal/setupHands";
-export let foveation = 1;
-export let frameRate = void 0;
-export let referenceSpace = "local-floor";
-const dispatch = createRawEventDispatcher();
+let {
+  foveation = 1,
+  frameRate,
+  referenceSpace = "local-floor",
+  ...props
+} = $props();
 const { renderer, renderMode } = useThrelte();
 const { xr } = renderer;
 let originalRenderMode = $renderMode;
@@ -43,22 +45,22 @@ setupControllers();
 setupHands();
 const handleSessionStart = () => {
   isPresenting.set(true);
-  dispatch("sessionstart", { type: "sessionstart", target: $session });
+  props.$$events?.sessionstart?.({ type: "sessionstart", target: $session });
 };
 const handleSessionEnd = () => {
-  dispatch("sessionend", { type: "sessionend", target: $session });
+  props.$$events?.sessionend?.({ type: "sessionend", target: $session });
   isPresenting.set(false);
   session.set(void 0);
 };
 const handleVisibilityChange = (event) => {
-  dispatch("visibilitychange", { ...event, target: $session });
+  props.$$events?.visibilitychange?.({ ...event, target: $session });
 };
 const handleInputSourcesChange = (event) => {
   $isHandTracking = Object.values(event.session.inputSources).some((source) => source.hand);
-  dispatch("inputsourceschange", { ...event, target: $session });
+  props.$$events?.inputsourceschange?.({ ...event, target: $session });
 };
 const handleFramerateChange = (event) => {
-  dispatch("visibilitychange", { ...event, target: $session });
+  props.$$events?.visibilitychange?.({ ...event, target: $session });
 };
 const updateTargetFrameRate = (frameRate2) => {
   if (frameRate2 === void 0)
@@ -102,14 +104,12 @@ onMount(() => {
     xr.removeEventListener("sessionend", handleSessionEnd);
   };
 });
-$:
-  updateTargetFrameRate(frameRate);
-$:
-  xr.setFoveation(foveation);
-$: {
+$effect.pre(() => updateTargetFrameRate(frameRate));
+$effect.pre(() => xr.setFoveation(foveation));
+$effect.pre(() => {
   xr.setReferenceSpaceType(referenceSpace);
   $referenceSpaceType = referenceSpace;
-}
+});
 </script>
 
 {#if $isPresenting}

package/dist/components/XR.svelte.d.ts

@@ -4,21 +4,35 @@ import type { XRSessionEvent } from '../types';
 declare const __propDef: {
     props: {
         /**
-           * Enables foveated rendering. Default is `1`, the three.js default.
-           *
-           * 0 = no foveation, full resolution
-           *
-           * 1 = maximum foveation, the edges render at lower resolution
-           */ foveation?: number | undefined;
+         * Enables foveated rendering. Default is `1`, the three.js default.
+         *
+         * 0 = no foveation, full resolution
+         *
+         * 1 = maximum foveation, the edges render at lower resolution
+         */
+        foveation?: number | undefined;
         /**
-           * The target framerate for the XRSystem. Smaller rates give more CPU headroom at the cost of responsiveness.
-           * Recommended range is `72`-`120`. Default is unset and left to the device.
-           * @note If your experience cannot effectively reach the target framerate, it will be subject to frame reprojection
-           * which will halve the effective framerate. Choose a conservative estimate that balances responsiveness and
-           * headroom based on your experience.
-           * @see https://developer.mozilla.org/en-US/docs/Web/API/WebXR_Device_API/Rendering#refresh_rate_and_frame_rate
-           */ frameRate?: number | undefined;
-        /** Type of WebXR reference space to use. Default is `local-floor` */ referenceSpace?: XRReferenceSpaceType | undefined;
+         * The target framerate for the XRSystem. Smaller rates give more CPU headroom at the cost of responsiveness.
+         * Recommended range is `72`-`120`. Default is unset and left to the device.
+         * @note If your experience cannot effectively reach the target framerate, it will be subject to frame reprojection
+         * which will halve the effective framerate. Choose a conservative estimate that balances responsiveness and
+         * headroom based on your experience.
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/WebXR_Device_API/Rendering#refresh_rate_and_frame_rate
+         */
+        frameRate?: number | undefined;
+        /** Type of WebXR reference space to use. Default is `local-floor` */
+        referenceSpace?: XRReferenceSpaceType | undefined;
+    } & {
+        $$events: {
+            /** Called as an XRSession is requested */
+            sessionstart(): XRSessionEvent<'sessionstart'>;
+            /** Called after an XRSession is terminated */
+            sessionend(): XRSessionEvent<'sessionend'>;
+            /** Called when an XRSession is hidden or unfocused. */
+            visibilitychange(): globalThis.XRSessionEvent;
+            /** Called when available inputsources change */
+            inputsourceschange(): globalThis.XRSessionEvent;
+        };
     };
     slots: {
         default: {};
@@ -26,13 +40,13 @@ declare const __propDef: {
     };
     events: {
         /** Called as an XRSession is requested */
-        sessionstart: XRSessionEvent<'sessionstart'>;
+        sessionstart(): XRSessionEvent<'sessionstart'>;
         /** Called after an XRSession is terminated */
-        sessionend: XRSessionEvent<'sessionend'>;
+        sessionend(): XRSessionEvent<'sessionend'>;
         /** Called when an XRSession is hidden or unfocused. */
-        visibilitychange: globalThis.XRSessionEvent;
+        visibilitychange(): globalThis.XRSessionEvent;
         /** Called when available inputsources change */
-        inputsourceschange: globalThis.XRSessionEvent;
+        inputsourceschange(): globalThis.XRSessionEvent;
     };
 };
 export type XrProps = typeof __propDef.props;

package/dist/components/XRButton.svelte

@@ -17,39 +17,34 @@ display info about your WebXR session. This is aliased by `ARButton` and
   />
 ```
 -->
-<script>import { createEventDispatcher } from "svelte";
-import { getXRSupportState } from "../lib/getXRSupportState";
+<script>import { getXRSupportState } from "../lib/getXRSupportState";
 import { toggleXRSession } from "../lib/toggleXRSession";
 import { session, xr } from "../internal/stores";
-export let mode;
-export let sessionInit = void 0;
-export let force = void 0;
-export let styled = true;
-const dispatch = createEventDispatcher();
+let { mode, sessionInit, force, styled = true, ...props } = $props();
 const handleButtonClick = async (nativeEvent, state) => {
   if (!$xr) {
     throw new Error(
       "The <XR> component was not created. This is required to start an XR session."
     );
   }
-  dispatch("click", { state, nativeEvent });
+  props.$$events?.click?.({ state, nativeEvent });
   if (state !== "supported")
     return;
   try {
     await toggleXRSession(mode, sessionInit, force);
   } catch (error) {
-    dispatch("error", error);
+    props.$$events?.error?.(error);
   }
 };
-$:
-  modeText = {
+let modeText = $derived(
+  {
     "immersive-vr": "VR",
     "immersive-ar": "AR",
     inline: "inline"
-  }[mode];
-$:
-  if (styled) {
-    $$restProps.style = `
+  }[mode]
+);
+let style = $derived(
+  styled ? `
       position: absolute;
       bottom: 24px;
       left: 50%;
@@ -60,15 +55,18 @@ $:
       color: white;
       outline: none;
       z-index: 10;
-      ${$$restProps.style ?? ""}
-    `;
-  }
+      ${props.style ?? ""}
+    ` : props.style
+);
 </script>
 
 {#await getXRSupportState(mode) then state}
   <button
-    {...$$restProps}
-    on:click={(event) => handleButtonClick(event, state)}
+    on:click={(event) => {
+      handleButtonClick(event, state)
+    }}
+    {...props}
+    {style}
   >
     {#if state === 'unsupported'}
       {modeText} unsupported

package/dist/components/XRButton.svelte.d.ts

@@ -3,22 +3,23 @@ import { SvelteComponent } from "svelte";
 import type { HTMLButtonAttributes } from 'svelte/elements';
 declare const __propDef: {
     props: HTMLButtonAttributes & {
+        /** The type of `XRSession` to create */
         mode: XRSessionMode;
+        /**
+         * `XRSession` configuration options
+         * @see https://immersive-web.github.io/webxr/#feature-dependencies
+         */
         sessionInit?: (XRSessionInit & {
             domOverlay?: {
                 root: HTMLElement;
             } | undefined;
         }) | undefined;
+        /** Whether this button should only enter / exit an `XRSession`. Default is to toggle both ways */
         force?: "enter" | "exit" | undefined;
+        /** Whether to apply automatic styling to the button. Set false to apply custom styles. Default is true. */
         styled?: boolean | undefined;
     };
     events: {
-        click: CustomEvent<{
-            state: 'unsupported' | 'insecure' | 'blocked' | 'supported';
-            nativeEvent: MouseEvent;
-        }>;
-        error: CustomEvent<Error>;
-    } & {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};

package/dist/hooks/useXR.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="webxr" />
 import type { CurrentWritable } from '@threlte/core';
-import { isPresenting, isHandTracking, session } from '../internal/stores';
 /**
  * Provides access to context related to `<XR />`.
  */

package/dist/internal/setupControllers.js

@@ -3,7 +3,7 @@ import { useThrelte } from '@threlte/core';
 import { onMount } from 'svelte';
 import { useHandTrackingState } from './useHandTrackingState';
 import { gaze, left, right } from '../hooks/useController';
-import { controllerDispatchers } from './stores';
+import { controllerEvents } from './stores';
 export const setupControllers = () => {
     const factory = new XRControllerModelFactory();
     const stores = { left, right, none: gaze };
@@ -23,7 +23,7 @@ export const setupControllers = () => {
             if (hasHands())
                 return;
             const { data } = event;
-            controllerDispatchers[data.handedness]?.current?.(event.type, event);
+            controllerEvents[data.handedness]?.[event.type]?.(event);
         };
         function handleConnected(event) {
             const { model, targetRay, grip } = indexMap.get(this);

package/dist/internal/setupHands.js

@@ -3,7 +3,7 @@ import { useThrelte } from '@threlte/core';
 import { onMount } from 'svelte';
 import { left, right } from '../hooks/useHand';
 import { useHandTrackingState } from './useHandTrackingState';
-import { handDispatchers } from './stores';
+import { handEvents } from './stores';
 export const setupHands = () => {
     const factory = new XRHandModelFactory();
     const stores = { left, right };
@@ -24,7 +24,7 @@ export const setupHands = () => {
                 return;
             const handEvent = event;
             const handedness = 'handedness' in handEvent ? handEvent.handedness : handEvent.data.handedness;
-            handDispatchers[handedness]?.current?.(event.type, event);
+            handEvents[handedness]?.[event.type]?.(event);
         };
         function handleConnected(event) {
             const hand = this;

package/dist/internal/setupRaf.js

@@ -1,5 +1,5 @@
 // @ts-expect-error svelte/internal is untyped.
-import { set_raf } from 'svelte/internal';
+// import { set_raf } from 'svelte/internal'
 import { onDestroy } from 'svelte';
 import { watch } from '@threlte/core';
 import { session } from './stores';
@@ -8,7 +8,7 @@ export const setupRaf = () => {
         return;
     const browserRaf = (fn) => requestAnimationFrame(fn);
     const currentRaf = { fn: browserRaf };
-    set_raf((fn) => currentRaf.fn(fn));
+    // set_raf((fn: FrameRequestCallback) => currentRaf.fn(fn))
     watch(session, (session) => {
         if (session) {
             currentRaf.fn = (fn) => session.requestAnimationFrame(fn);

package/dist/internal/stores.d.ts

@@ -5,21 +5,13 @@ export declare const isHandTracking: import("@threlte/core").CurrentWritable<boo
 export declare const session: import("@threlte/core").CurrentWritable<XRSession | undefined>;
 export declare const referenceSpaceType: import("@threlte/core").CurrentWritable<XRReferenceSpaceType | undefined>;
 export declare const xr: import("@threlte/core").CurrentWritable<WebXRManager | undefined>;
-export declare const controllerDispatchers: {
-    left: import("@threlte/core").CurrentWritable<((<Type extends string>(type: Type, payload?: unknown) => void) & {
-        hasEventListener: <Type_1 extends string>(type: Type_1) => boolean;
-    }) | undefined>;
-    right: import("@threlte/core").CurrentWritable<((<Type extends string>(type: Type, payload?: unknown) => void) & {
-        hasEventListener: <Type_1 extends string>(type: Type_1) => boolean;
-    }) | undefined>;
+export declare const controllerEvents: {
+    left: import("@threlte/core").CurrentWritable<Record<string, (arg: unknown) => void> | undefined>;
+    right: import("@threlte/core").CurrentWritable<Record<string, (arg: unknown) => void> | undefined>;
 };
-export declare const handDispatchers: {
-    left: import("@threlte/core").CurrentWritable<((<Type extends string>(type: Type, payload?: unknown) => void) & {
-        hasEventListener: <Type_1 extends string>(type: Type_1) => boolean;
-    }) | undefined>;
-    right: import("@threlte/core").CurrentWritable<((<Type extends string>(type: Type, payload?: unknown) => void) & {
-        hasEventListener: <Type_1 extends string>(type: Type_1) => boolean;
-    }) | undefined>;
+export declare const handEvents: {
+    left: import("@threlte/core").CurrentWritable<Record<string, (arg: unknown) => void> | undefined>;
+    right: import("@threlte/core").CurrentWritable<Record<string, (arg: unknown) => void> | undefined>;
 };
 export declare const teleportState: import("@threlte/core").CurrentWritable<{
     left: {

package/dist/internal/stores.js

@@ -4,11 +4,11 @@ export const isHandTracking = currentWritable(false);
 export const session = currentWritable(undefined);
 export const referenceSpaceType = currentWritable(undefined);
 export const xr = currentWritable(undefined);
-export const controllerDispatchers = {
+export const controllerEvents = {
     left: currentWritable(undefined),
     right: currentWritable(undefined)
 };
-export const handDispatchers = {
+export const handEvents = {
     left: currentWritable(undefined),
     right: currentWritable(undefined)
 };

package/dist/plugins/pointerControls/useComponentEventHandlers.js

@@ -1,13 +1,11 @@
 import { onMount } from 'svelte';
-import { get_current_component } from 'svelte/internal';
 import { writable } from 'svelte/store';
-import { events } from './types';
+// import { events } from './types'
 export const useComponentHasEventHandlers = () => {
-    const component = get_current_component();
     const hasEventHandlers = writable(false);
     onMount(() => {
-        const match = Object.keys(component.$$.callbacks).some((callback) => events.includes(callback));
-        hasEventHandlers.set(match);
+        // const match = Object.keys(component.$$.callbacks).some((callback) => events.includes(callback))
+        hasEventHandlers.set(true);
     });
     return {
         hasEventHandlers

package/package.json

@@ -1,29 +1,29 @@
 {
   "name": "@threlte/xr",
-  "version": "0.1.3",
+  "version": "1.0.0-next.0",
   "author": "Micheal Parks <michealparks1989@gmail.com> (https://parks.lol)",
   "license": "MIT",
   "devDependencies": {
-    "@sveltejs/adapter-auto": "^3.1.1",
-    "@sveltejs/kit": "^2.4.3",
-    "@sveltejs/package": "^2.2.6",
-    "@sveltejs/vite-plugin-svelte": "^3.0.1",
-    "@typescript-eslint/eslint-plugin": "^6.19.1",
-    "@typescript-eslint/parser": "^6.19.1",
-    "eslint": "^8.56.0",
-    "eslint-plugin-svelte": "^2.35.1",
-    "svelte-check": "^3.6.3",
-    "typescript": "^5.3.3",
-    "@types/three": "^0.160.0",
-    "autoprefixer": "^10.4.17",
-    "postcss": "^8.4.33",
+    "@sveltejs/adapter-auto": "^3.2.0",
+    "@sveltejs/kit": "^2.5.5",
+    "@sveltejs/package": "^2.3.1",
+    "@sveltejs/vite-plugin-svelte": "^3.0.2",
+    "@typescript-eslint/eslint-plugin": "^7.5.0",
+    "@typescript-eslint/parser": "^7.5.0",
+    "eslint": "^9.0.0",
+    "eslint-plugin-svelte": "^2.36.0",
+    "svelte-check": "^3.6.9",
+    "typescript": "^5.4.4",
+    "@types/three": "^0.163.0",
+    "autoprefixer": "^10.4.19",
+    "postcss": "^8.4.38",
     "publint": "^0.2.7",
-    "svelte": "^4.2.9",
-    "three": "^0.160.1",
+    "svelte": "^4.2.12",
+    "three": "^0.163.0",
     "tslib": "^2.6.2",
-    "vite": "^5.0.12",
-    "vite-plugin-mkcert": "^1.17.3",
-    "@threlte/core": "7.2.1"
+    "vite": "^5.2.8",
+    "vite-plugin-mkcert": "^1.17.5",
+    "@threlte/core": "8.0.0-next.0"
   },
   "peerDependencies": {
     "svelte": ">=4",

package/dist/plugins/pointerControls/context.d.ts

@@ -1,12 +0,0 @@
-import type { createRawEventDispatcher } from '@threlte/core';
-import type { ControlsContext, HandContext, ThrelteXREvents } from './types';
-export declare const getHandContext: (hand: 'left' | 'right') => HandContext;
-export declare const setHandContext: (hand: 'left' | 'right', context: HandContext) => void;
-export declare const getControlsContext: () => ControlsContext;
-export declare const setControlsContext: (context: ControlsContext) => void;
-interface InternalContext {
-    dispatchers: WeakMap<THREE.Object3D, ReturnType<typeof createRawEventDispatcher<ThrelteXREvents>>>;
-}
-export declare const getInternalContext: () => InternalContext;
-export declare const setInternalContext: () => void;
-export {};