@react-three/fiber 9.2.0 → 9.3.0

package/dist/declarations/src/core/utils.d.ts

@@ -1,191 +1,191 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import { Instance } from "./reconciler.js";
-import type { Fiber } from 'react-reconciler';
-import type { Dpr, RootStore, Size } from "./store.js";
-export type NonFunctionKeys<P> = {
-    [K in keyof P]-?: P[K] extends Function ? never : K;
-}[keyof P];
-export type Overwrite<P, O> = Omit<P, NonFunctionKeys<O>> & O;
-export type Properties<T> = Pick<T, NonFunctionKeys<T>>;
-export type Mutable<P> = {
-    [K in keyof P]: P[K] | Readonly<P[K]>;
-};
-export type IsOptional<T> = undefined extends T ? true : false;
-export type IsAllOptional<T extends any[]> = T extends [infer First, ...infer Rest] ? IsOptional<First> extends true ? IsAllOptional<Rest> : false : true;
-/**
- * Returns the instance's initial (outmost) root.
- */
-export declare function findInitialRoot<T>(instance: Instance<T>): RootStore;
-export type Act = <T = any>(cb: () => Promise<T>) => Promise<T>;
-/**
- * Safely flush async effects when testing, simulating a legacy root.
- * @deprecated Import from React instead. import { act } from 'react'
- */
-export declare const act: Act;
-export type Camera = (THREE.OrthographicCamera | THREE.PerspectiveCamera) & {
-    manual?: boolean;
-};
-export declare const isOrthographicCamera: (def: Camera) => def is THREE.OrthographicCamera;
-export declare const isRef: (obj: any) => obj is React.RefObject<unknown>;
-export declare const isColorRepresentation: (value: unknown) => value is THREE.ColorRepresentation;
-/**
- * An SSR-friendly useLayoutEffect.
- *
- * React currently throws a warning when using useLayoutEffect on the server.
- * To get around it, we can conditionally useEffect on the server (no-op) and
- * useLayoutEffect elsewhere.
- *
- * @see https://github.com/facebook/react/issues/14927
- */
-export declare const useIsomorphicLayoutEffect: typeof React.useLayoutEffect;
-export declare function useMutableCallback<T>(fn: T): React.RefObject<T>;
-export type Bridge = React.FC<{
-    children?: React.ReactNode;
-}>;
-/**
- * Bridges renderer Context and StrictMode from a primary renderer.
- */
-export declare function useBridge(): Bridge;
-export type SetBlock = false | Promise<null> | null;
-export type UnblockProps = {
-    set: React.Dispatch<React.SetStateAction<SetBlock>>;
-    children: React.ReactNode;
-};
-export declare function Block({ set }: Omit<UnblockProps, 'children'>): null;
-export declare const ErrorBoundary: {
-    new (props: {
-        set: React.Dispatch<Error | undefined>;
-        children: React.ReactNode;
-    }): {
-        state: {
-            error: boolean;
-        };
-        componentDidCatch(err: Error): void;
-        render(): React.ReactNode;
-        context: unknown;
-        setState<K extends "error">(state: {
-            error: boolean;
-        } | ((prevState: Readonly<{
-            error: boolean;
-        }>, props: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>) => {
-            error: boolean;
-        } | Pick<{
-            error: boolean;
-        }, K> | null) | Pick<{
-            error: boolean;
-        }, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>;
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>): boolean;
-        componentWillUnmount?(): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>, prevState: Readonly<{
-            error: boolean;
-        }>): any;
-        componentDidUpdate?(prevProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>, prevState: Readonly<{
-            error: boolean;
-        }>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>): void;
-        componentWillUpdate?(nextProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>): void;
-    };
-    getDerivedStateFromError: () => {
-        error: boolean;
-    };
-    contextType?: React.Context<any> | undefined;
-    propTypes?: any;
-};
-export interface ObjectMap {
-    nodes: {
-        [name: string]: THREE.Object3D;
-    };
-    materials: {
-        [name: string]: THREE.Material;
-    };
-    meshes: {
-        [name: string]: THREE.Mesh;
-    };
-}
-export declare function calculateDpr(dpr: Dpr): number;
-/**
- * Returns instance root state
- */
-export declare function getRootState<T extends THREE.Object3D = THREE.Object3D>(obj: T): import("./store.js").RootState | undefined;
-export interface EquConfig {
-    /** Compare arrays by reference equality a === b (default), or by shallow equality */
-    arrays?: 'reference' | 'shallow';
-    /** Compare objects by reference equality a === b (default), or by shallow equality */
-    objects?: 'reference' | 'shallow';
-    /** If true the keys in both a and b must match 1:1 (default), if false a's keys must intersect b's */
-    strict?: boolean;
-}
-export declare const is: {
-    obj: (a: any) => boolean;
-    fun: (a: any) => a is Function;
-    str: (a: any) => a is string;
-    num: (a: any) => a is number;
-    boo: (a: any) => a is boolean;
-    und: (a: any) => boolean;
-    nul: (a: any) => boolean;
-    arr: (a: any) => boolean;
-    equ(a: any, b: any, { arrays, objects, strict }?: EquConfig): boolean;
-};
-export declare function buildGraph(object: THREE.Object3D): ObjectMap;
-export interface Disposable {
-    type?: string;
-    dispose?: () => void;
-}
-export declare function dispose<T extends Disposable>(obj: T): void;
-export declare const REACT_INTERNAL_PROPS: string[];
-export declare function getInstanceProps<T = any>(queue: Fiber['pendingProps']): Instance<T>['props'];
-export declare function prepare<T = any>(target: T, root: RootStore, type: string, props: Instance<T>['props']): Instance<T>;
-export declare function resolve(root: any, key: string): {
-    root: any;
-    key: string;
-    target: any;
-};
-export declare function attach(parent: Instance, child: Instance): void;
-export declare function detach(parent: Instance, child: Instance): void;
-export declare const RESERVED_PROPS: string[];
-export declare function diffProps<T = any>(instance: Instance<T>, newProps: Instance<T>['props']): Instance<T>['props'];
-export declare function applyProps<T = any>(object: Instance<T>['object'], props: Instance<T>['props']): Instance<T>['object'];
-export declare function invalidateInstance(instance: Instance): void;
-export declare function updateCamera(camera: Camera, size: Size): void;
-export declare const isObject3D: (object: any) => object is THREE.Object3D<THREE.Object3DEventMap>;
+import * as THREE from 'three';
+import * as React from 'react';
+import { Instance } from "./reconciler.js";
+import type { Fiber } from 'react-reconciler';
+import type { Dpr, RootStore, Size } from "./store.js";
+export type NonFunctionKeys<P> = {
+    [K in keyof P]-?: P[K] extends Function ? never : K;
+}[keyof P];
+export type Overwrite<P, O> = Omit<P, NonFunctionKeys<O>> & O;
+export type Properties<T> = Pick<T, NonFunctionKeys<T>>;
+export type Mutable<P> = {
+    [K in keyof P]: P[K] | Readonly<P[K]>;
+};
+export type IsOptional<T> = undefined extends T ? true : false;
+export type IsAllOptional<T extends any[]> = T extends [infer First, ...infer Rest] ? IsOptional<First> extends true ? IsAllOptional<Rest> : false : true;
+/**
+ * Returns the instance's initial (outmost) root.
+ */
+export declare function findInitialRoot<T>(instance: Instance<T>): RootStore;
+export type Act = <T = any>(cb: () => Promise<T>) => Promise<T>;
+/**
+ * Safely flush async effects when testing, simulating a legacy root.
+ * @deprecated Import from React instead. import { act } from 'react'
+ */
+export declare const act: Act;
+export type Camera = (THREE.OrthographicCamera | THREE.PerspectiveCamera) & {
+    manual?: boolean;
+};
+export declare const isOrthographicCamera: (def: Camera) => def is THREE.OrthographicCamera;
+export declare const isRef: (obj: any) => obj is React.RefObject<unknown>;
+export declare const isColorRepresentation: (value: unknown) => value is THREE.ColorRepresentation;
+/**
+ * An SSR-friendly useLayoutEffect.
+ *
+ * React currently throws a warning when using useLayoutEffect on the server.
+ * To get around it, we can conditionally useEffect on the server (no-op) and
+ * useLayoutEffect elsewhere.
+ *
+ * @see https://github.com/facebook/react/issues/14927
+ */
+export declare const useIsomorphicLayoutEffect: typeof React.useLayoutEffect;
+export declare function useMutableCallback<T>(fn: T): React.RefObject<T>;
+export type Bridge = React.FC<{
+    children?: React.ReactNode;
+}>;
+/**
+ * Bridges renderer Context and StrictMode from a primary renderer.
+ */
+export declare function useBridge(): Bridge;
+export type SetBlock = false | Promise<null> | null;
+export type UnblockProps = {
+    set: React.Dispatch<React.SetStateAction<SetBlock>>;
+    children: React.ReactNode;
+};
+export declare function Block({ set }: Omit<UnblockProps, 'children'>): null;
+export declare const ErrorBoundary: {
+    new (props: {
+        set: React.Dispatch<Error | undefined>;
+        children: React.ReactNode;
+    }): {
+        state: {
+            error: boolean;
+        };
+        componentDidCatch(err: Error): void;
+        render(): React.ReactNode;
+        context: unknown;
+        setState<K extends "error">(state: {
+            error: boolean;
+        } | ((prevState: Readonly<{
+            error: boolean;
+        }>, props: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>) => {
+            error: boolean;
+        } | Pick<{
+            error: boolean;
+        }, K> | null) | Pick<{
+            error: boolean;
+        }, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>): boolean;
+        componentWillUnmount?(): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, prevState: Readonly<{
+            error: boolean;
+        }>): any;
+        componentDidUpdate?(prevProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, prevState: Readonly<{
+            error: boolean;
+        }>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>): void;
+        componentWillUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>): void;
+    };
+    getDerivedStateFromError: () => {
+        error: boolean;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};
+export interface ObjectMap {
+    nodes: {
+        [name: string]: THREE.Object3D;
+    };
+    materials: {
+        [name: string]: THREE.Material;
+    };
+    meshes: {
+        [name: string]: THREE.Mesh;
+    };
+}
+export declare function calculateDpr(dpr: Dpr): number;
+/**
+ * Returns instance root state
+ */
+export declare function getRootState<T extends THREE.Object3D = THREE.Object3D>(obj: T): import("./store.js").RootState | undefined;
+export interface EquConfig {
+    /** Compare arrays by reference equality a === b (default), or by shallow equality */
+    arrays?: 'reference' | 'shallow';
+    /** Compare objects by reference equality a === b (default), or by shallow equality */
+    objects?: 'reference' | 'shallow';
+    /** If true the keys in both a and b must match 1:1 (default), if false a's keys must intersect b's */
+    strict?: boolean;
+}
+export declare const is: {
+    obj: (a: any) => boolean;
+    fun: (a: any) => a is Function;
+    str: (a: any) => a is string;
+    num: (a: any) => a is number;
+    boo: (a: any) => a is boolean;
+    und: (a: any) => boolean;
+    nul: (a: any) => boolean;
+    arr: (a: any) => boolean;
+    equ(a: any, b: any, { arrays, objects, strict }?: EquConfig): boolean;
+};
+export declare function buildGraph(object: THREE.Object3D): ObjectMap;
+export interface Disposable {
+    type?: string;
+    dispose?: () => void;
+}
+export declare function dispose<T extends Disposable>(obj: T): void;
+export declare const REACT_INTERNAL_PROPS: string[];
+export declare function getInstanceProps<T = any>(queue: Fiber['pendingProps']): Instance<T>['props'];
+export declare function prepare<T = any>(target: T, root: RootStore, type: string, props: Instance<T>['props']): Instance<T>;
+export declare function resolve(root: any, key: string): {
+    root: any;
+    key: string;
+    target: any;
+};
+export declare function attach(parent: Instance, child: Instance): void;
+export declare function detach(parent: Instance, child: Instance): void;
+export declare const RESERVED_PROPS: string[];
+export declare function diffProps<T = any>(instance: Instance<T>, newProps: Instance<T>['props']): Instance<T>['props'];
+export declare function applyProps<T = any>(object: Instance<T>['object'], props: Instance<T>['props']): Instance<T>['object'];
+export declare function invalidateInstance(instance: Instance): void;
+export declare function updateCamera(camera: Camera, size: Size): void;
+export declare const isObject3D: (object: any) => object is THREE.Object3D<THREE.Object3DEventMap>;

package/dist/declarations/src/index.d.ts

@@ -1,6 +1,6 @@
-import * as ReactThreeFiber from "./three-types.js";
-export { ReactThreeFiber };
-export * from "./three-types.js";
-export * from "./core/index.js";
-export * from "./web/Canvas.js";
-export { createPointerEvents as events } from "./web/events.js";
+import * as ReactThreeFiber from "./three-types.js";
+export { ReactThreeFiber };
+export * from "./three-types.js";
+export * from "./core/index.js";
+export * from "./web/Canvas.js";
+export { createPointerEvents as events } from "./web/events.js";

package/dist/declarations/src/native/Canvas.d.ts

@@ -1,13 +1,13 @@
-import * as React from 'react';
-import { View, type ViewProps, type ViewStyle } from 'react-native';
-import { RenderProps } from "../core/index.js";
-export interface CanvasProps extends Omit<RenderProps<HTMLCanvasElement>, 'size' | 'dpr'>, Omit<ViewProps, 'children'> {
-    children?: React.ReactNode;
-    style?: ViewStyle;
-    ref?: React.Ref<View>;
-}
-/**
- * A native canvas which accepts threejs elements as children.
- * @see https://docs.pmnd.rs/react-three-fiber/api/canvas
- */
-export declare function Canvas(props: CanvasProps): import("react/jsx-runtime").JSX.Element;
+import * as React from 'react';
+import { View, type ViewProps, type ViewStyle } from 'react-native';
+import { RenderProps } from "../core/index.js";
+export interface CanvasProps extends Omit<RenderProps<HTMLCanvasElement>, 'size' | 'dpr'>, Omit<ViewProps, 'children'> {
+    children?: React.ReactNode;
+    style?: ViewStyle;
+    ref?: React.Ref<View>;
+}
+/**
+ * A native canvas which accepts threejs elements as children.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/canvas
+ */
+export declare function Canvas(props: CanvasProps): import("react/jsx-runtime").JSX.Element;

package/dist/declarations/src/native/events.d.ts

@@ -1,4 +1,4 @@
-import { RootStore } from "../core/store.js";
-import { EventManager } from "../core/events.js";
-/** Default R3F event manager for react-native */
-export declare function createTouchEvents(store: RootStore): EventManager<HTMLElement>;
+import { RootStore } from "../core/store.js";
+import { EventManager } from "../core/events.js";
+/** Default R3F event manager for react-native */
+export declare function createTouchEvents(store: RootStore): EventManager<HTMLElement>;

package/dist/declarations/src/native.d.ts

@@ -1,6 +1,6 @@
-import * as ReactThreeFiber from "./three-types.js";
-export { ReactThreeFiber };
-export * from "./three-types.js";
-export * from "./core/index.js";
-export * from "./native/Canvas.js";
-export { createTouchEvents as events } from "./native/events.js";
+import * as ReactThreeFiber from "./three-types.js";
+export { ReactThreeFiber };
+export * from "./three-types.js";
+export * from "./core/index.js";
+export * from "./native/Canvas.js";
+export { createTouchEvents as events } from "./native/events.js";

package/dist/declarations/src/three-types.d.ts

@@ -1,68 +1,68 @@
-import type * as THREE from 'three';
-import type { Args, EventHandlers, InstanceProps, ConstructorRepresentation } from "./core/index.js";
-import type { Overwrite, Mutable } from "./core/utils.js";
-type MutableOrReadonlyParameters<T extends (...args: any) => any> = Parameters<T> | Readonly<Parameters<T>>;
-export interface MathRepresentation {
-    set(...args: number[]): any;
-}
-export interface VectorRepresentation extends MathRepresentation {
-    setScalar(value: number): any;
-}
-export type MathTypes = MathRepresentation | THREE.Euler | THREE.Color;
-export type MathType<T extends MathTypes> = T extends THREE.Color ? Args<typeof THREE.Color> | THREE.ColorRepresentation : T extends VectorRepresentation | THREE.Layers | THREE.Euler ? T | MutableOrReadonlyParameters<T['set']> | number : T | MutableOrReadonlyParameters<T['set']>;
-export type MathProps<P> = {
-    [K in keyof P as P[K] extends MathTypes ? K : never]: P[K] extends MathTypes ? MathType<P[K]> : never;
-};
-export type Vector2 = MathType<THREE.Vector2>;
-export type Vector3 = MathType<THREE.Vector3>;
-export type Vector4 = MathType<THREE.Vector4>;
-export type Color = MathType<THREE.Color>;
-export type Layers = MathType<THREE.Layers>;
-export type Quaternion = MathType<THREE.Quaternion>;
-export type Euler = MathType<THREE.Euler>;
-export type Matrix3 = MathType<THREE.Matrix3>;
-export type Matrix4 = MathType<THREE.Matrix4>;
-export interface RaycastableRepresentation {
-    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
-}
-export type EventProps<P> = P extends RaycastableRepresentation ? Partial<EventHandlers> : {};
-export interface ReactProps<P> {
-    children?: React.ReactNode;
-    ref?: React.Ref<P>;
-    key?: React.Key;
-}
-export type ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = Partial<Overwrite<P, MathProps<P> & ReactProps<P> & EventProps<P>>>;
-export type ThreeElement<T extends ConstructorRepresentation> = Mutable<Overwrite<ElementProps<T>, Omit<InstanceProps<InstanceType<T>, T>, 'object'>>>;
-export type ThreeToJSXElements<T extends Record<string, any>> = {
-    [K in keyof T & string as Uncapitalize<K>]: T[K] extends ConstructorRepresentation ? ThreeElement<T[K]> : never;
-};
-type ThreeExports = typeof THREE;
-type ThreeElementsImpl = ThreeToJSXElements<ThreeExports>;
-export interface ThreeElements extends Omit<ThreeElementsImpl, 'audio' | 'source' | 'line' | 'path'> {
-    primitive: Omit<ThreeElement<any>, 'args'> & {
-        object: object;
-    };
-    threeAudio: ThreeElementsImpl['audio'];
-    threeSource: ThreeElementsImpl['source'];
-    threeLine: ThreeElementsImpl['line'];
-    threePath: ThreeElementsImpl['path'];
-}
-declare module 'react' {
-    namespace JSX {
-        interface IntrinsicElements extends ThreeElements {
-        }
-    }
-}
-declare module 'react/jsx-runtime' {
-    namespace JSX {
-        interface IntrinsicElements extends ThreeElements {
-        }
-    }
-}
-declare module 'react/jsx-dev-runtime' {
-    namespace JSX {
-        interface IntrinsicElements extends ThreeElements {
-        }
-    }
-}
-export {};
+import type * as THREE from 'three';
+import type { Args, EventHandlers, InstanceProps, ConstructorRepresentation } from "./core/index.js";
+import type { Overwrite, Mutable } from "./core/utils.js";
+type MutableOrReadonlyParameters<T extends (...args: any) => any> = Parameters<T> | Readonly<Parameters<T>>;
+export interface MathRepresentation {
+    set(...args: number[]): any;
+}
+export interface VectorRepresentation extends MathRepresentation {
+    setScalar(value: number): any;
+}
+export type MathTypes = MathRepresentation | THREE.Euler | THREE.Color;
+export type MathType<T extends MathTypes> = T extends THREE.Color ? Args<typeof THREE.Color> | THREE.ColorRepresentation : T extends VectorRepresentation | THREE.Layers | THREE.Euler ? T | MutableOrReadonlyParameters<T['set']> | number : T | MutableOrReadonlyParameters<T['set']>;
+export type MathProps<P> = {
+    [K in keyof P as P[K] extends MathTypes ? K : never]: P[K] extends MathTypes ? MathType<P[K]> : never;
+};
+export type Vector2 = MathType<THREE.Vector2>;
+export type Vector3 = MathType<THREE.Vector3>;
+export type Vector4 = MathType<THREE.Vector4>;
+export type Color = MathType<THREE.Color>;
+export type Layers = MathType<THREE.Layers>;
+export type Quaternion = MathType<THREE.Quaternion>;
+export type Euler = MathType<THREE.Euler>;
+export type Matrix3 = MathType<THREE.Matrix3>;
+export type Matrix4 = MathType<THREE.Matrix4>;
+export interface RaycastableRepresentation {
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+}
+export type EventProps<P> = P extends RaycastableRepresentation ? Partial<EventHandlers> : {};
+export interface ReactProps<P> {
+    children?: React.ReactNode;
+    ref?: React.Ref<P>;
+    key?: React.Key;
+}
+export type ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = Partial<Overwrite<P, MathProps<P> & ReactProps<P> & EventProps<P>>>;
+export type ThreeElement<T extends ConstructorRepresentation> = Mutable<Overwrite<ElementProps<T>, Omit<InstanceProps<InstanceType<T>, T>, 'object'>>>;
+export type ThreeToJSXElements<T extends Record<string, any>> = {
+    [K in keyof T & string as Uncapitalize<K>]: T[K] extends ConstructorRepresentation ? ThreeElement<T[K]> : never;
+};
+type ThreeExports = typeof THREE;
+type ThreeElementsImpl = ThreeToJSXElements<ThreeExports>;
+export interface ThreeElements extends Omit<ThreeElementsImpl, 'audio' | 'source' | 'line' | 'path'> {
+    primitive: Omit<ThreeElement<any>, 'args'> & {
+        object: object;
+    };
+    threeAudio: ThreeElementsImpl['audio'];
+    threeSource: ThreeElementsImpl['source'];
+    threeLine: ThreeElementsImpl['line'];
+    threePath: ThreeElementsImpl['path'];
+}
+declare module 'react' {
+    namespace JSX {
+        interface IntrinsicElements extends ThreeElements {
+        }
+    }
+}
+declare module 'react/jsx-runtime' {
+    namespace JSX {
+        interface IntrinsicElements extends ThreeElements {
+        }
+    }
+}
+declare module 'react/jsx-dev-runtime' {
+    namespace JSX {
+        interface IntrinsicElements extends ThreeElements {
+        }
+    }
+}
+export {};

package/dist/declarations/src/web/Canvas.d.ts

@@ -1,23 +1,23 @@
-import * as React from 'react';
-import { Options as ResizeOptions } from 'react-use-measure';
-import { RenderProps } from "../core/index.js";
-export interface CanvasProps extends Omit<RenderProps<HTMLCanvasElement>, 'size'>, React.HTMLAttributes<HTMLDivElement> {
-    children?: React.ReactNode;
-    ref?: React.Ref<HTMLCanvasElement>;
-    /** Canvas fallback content, similar to img's alt prop */
-    fallback?: React.ReactNode;
-    /**
-     * Options to pass to useMeasure.
-     * @see https://github.com/pmndrs/react-use-measure#api
-     */
-    resize?: ResizeOptions;
-    /** The target where events are being subscribed to, default: the div that wraps canvas */
-    eventSource?: HTMLElement | React.RefObject<HTMLElement>;
-    /** The event prefix that is cast into canvas pointer x/y events, default: "offset" */
-    eventPrefix?: 'offset' | 'client' | 'page' | 'layer' | 'screen';
-}
-/**
- * A DOM canvas which accepts threejs elements as children.
- * @see https://docs.pmnd.rs/react-three-fiber/api/canvas
- */
-export declare function Canvas(props: CanvasProps): import("react/jsx-runtime").JSX.Element;
+import * as React from 'react';
+import { Options as ResizeOptions } from 'react-use-measure';
+import { RenderProps } from "../core/index.js";
+export interface CanvasProps extends Omit<RenderProps<HTMLCanvasElement>, 'size'>, React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    ref?: React.Ref<HTMLCanvasElement>;
+    /** Canvas fallback content, similar to img's alt prop */
+    fallback?: React.ReactNode;
+    /**
+     * Options to pass to useMeasure.
+     * @see https://github.com/pmndrs/react-use-measure#api
+     */
+    resize?: ResizeOptions;
+    /** The target where events are being subscribed to, default: the div that wraps canvas */
+    eventSource?: HTMLElement | React.RefObject<HTMLElement>;
+    /** The event prefix that is cast into canvas pointer x/y events, default: "offset" */
+    eventPrefix?: 'offset' | 'client' | 'page' | 'layer' | 'screen';
+}
+/**
+ * A DOM canvas which accepts threejs elements as children.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/canvas
+ */
+export declare function Canvas(props: CanvasProps): import("react/jsx-runtime").JSX.Element;

package/dist/declarations/src/web/events.d.ts

@@ -1,4 +1,4 @@
-import { RootStore } from "../core/store.js";
-import { EventManager } from "../core/events.js";
-/** Default R3F event manager for web */
-export declare function createPointerEvents(store: RootStore): EventManager<HTMLElement>;
+import { RootStore } from "../core/store.js";
+import { EventManager } from "../core/events.js";
+/** Default R3F event manager for web */
+export declare function createPointerEvents(store: RootStore): EventManager<HTMLElement>;