@react-three/fiber 8.17.4 → 8.17.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @react-three/fiber
 
+## 8.17.5
+
+### Patch Changes
+
+- 162dbbdd: fix: npmignore ignored types"
+
 ## 8.17.4
 
 ### Patch Changes

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

@@ -0,0 +1,93 @@
+import * as THREE from 'three';
+import type { UseBoundStore } from 'zustand';
+import type { RootState } from './store';
+import type { Properties } from '../three-types';
+export interface Intersection extends THREE.Intersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
+}
+export interface IntersectionEvent<TSourceEvent> extends Intersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
+    /** An array of intersections */
+    intersections: Intersection[];
+    /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */
+    unprojectedPoint: THREE.Vector3;
+    /** Normalized event coordinates */
+    pointer: THREE.Vector2;
+    /** Delta between first click and this event */
+    delta: number;
+    /** The ray that pierced it */
+    ray: THREE.Ray;
+    /** The camera that was used by the raycaster */
+    camera: Camera;
+    /** stopPropagation will stop underlying handlers from firing */
+    stopPropagation: () => void;
+    /** The original host event */
+    nativeEvent: TSourceEvent;
+    /** If the event was stopped by calling stopPropagation */
+    stopped: boolean;
+}
+export declare type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
+export declare type ThreeEvent<TEvent> = IntersectionEvent<TEvent> & Properties<TEvent>;
+export declare type DomEvent = PointerEvent | MouseEvent | WheelEvent;
+export declare type Events = {
+    onClick: EventListener;
+    onContextMenu: EventListener;
+    onDoubleClick: EventListener;
+    onWheel: EventListener;
+    onPointerDown: EventListener;
+    onPointerUp: EventListener;
+    onPointerLeave: EventListener;
+    onPointerMove: EventListener;
+    onPointerCancel: EventListener;
+    onLostPointerCapture: EventListener;
+};
+export declare type EventHandlers = {
+    onClick?: (event: ThreeEvent<MouseEvent>) => void;
+    onContextMenu?: (event: ThreeEvent<MouseEvent>) => void;
+    onDoubleClick?: (event: ThreeEvent<MouseEvent>) => void;
+    onPointerUp?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerDown?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerOver?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerOut?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerEnter?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerLeave?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerMove?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerMissed?: (event: MouseEvent) => void;
+    onPointerCancel?: (event: ThreeEvent<PointerEvent>) => void;
+    onWheel?: (event: ThreeEvent<WheelEvent>) => void;
+};
+export declare type FilterFunction = (items: THREE.Intersection[], state: RootState) => THREE.Intersection[];
+export declare type ComputeFunction = (event: DomEvent, root: RootState, previous?: RootState) => void;
+export interface EventManager<TTarget> {
+    /** Determines if the event layer is active */
+    enabled: boolean;
+    /** Event layer priority, higher prioritized layers come first and may stop(-propagate) lower layer  */
+    priority: number;
+    /** The compute function needs to set up the raycaster and an xy- pointer  */
+    compute?: ComputeFunction;
+    /** The filter can re-order or re-structure the intersections  */
+    filter?: FilterFunction;
+    /** The target node the event layer is tied to */
+    connected?: TTarget;
+    /** All the pointer event handlers through which the host forwards native events */
+    handlers?: Events;
+    /** Allows re-connecting to another target */
+    connect?: (target: TTarget) => void;
+    /** Removes all existing events handlers from the target */
+    disconnect?: () => void;
+    /** Triggers a onPointerMove with the last known event. This can be useful to enable raycasting without
+     *  explicit user interaction, for instance when the camera moves a hoverable object underneath the cursor.
+     */
+    update?: () => void;
+}
+export interface PointerCaptureTarget {
+    intersection: Intersection;
+    target: Element;
+}
+export declare function getEventPriority(): 1 | 16 | 4;
+export declare function removeInteractivity(store: UseBoundStore<RootState>, object: THREE.Object3D): void;
+export declare function createEvents(store: UseBoundStore<RootState>): {
+    handlePointer: (name: string) => (event: DomEvent) => void;
+};

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

@@ -0,0 +1,57 @@
+import * as THREE from 'three';
+import * as React from 'react';
+import { StateSelector, EqualityChecker } from 'zustand';
+import { RootState, RenderCallback } from './store';
+import { ObjectMap } from './utils';
+import { LocalState } from './renderer';
+export interface Loader<T> extends THREE.Loader {
+    load(url: string, onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: unknown) => void): unknown;
+    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<T>;
+}
+export declare type LoaderProto<T> = new (...args: any) => Loader<T extends unknown ? any : T>;
+export declare type LoaderReturnType<T, L extends LoaderProto<T>> = T extends unknown ? Awaited<ReturnType<InstanceType<L>['loadAsync']>> : T;
+export declare type LoaderResult<T> = T extends any[] ? Loader<T[number]> : Loader<T>;
+export declare type Extensions<T extends {
+    prototype: LoaderProto<any>;
+}> = (loader: T['prototype']) => void;
+export declare type ConditionalType<Child, Parent, Truthy, Falsy> = Child extends Parent ? Truthy : Falsy;
+export declare type BranchingReturn<T, Parent, Coerced> = ConditionalType<T, Parent, Coerced, T>;
+/**
+ * Exposes an object's {@link LocalState}.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#useInstanceHandle
+ *
+ * **Note**: this is an escape hatch to react-internal fields. Expect this to change significantly between versions.
+ */
+export declare function useInstanceHandle<O>(ref: React.MutableRefObject<O>): React.MutableRefObject<LocalState>;
+export declare function useStore(): import("zustand").UseBoundStore<RootState, import("zustand").StoreApi<RootState>>;
+/**
+ * Accesses R3F's internal state, containing renderer, canvas, scene, etc.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usethree
+ */
+export declare function useThree<T = RootState>(selector?: StateSelector<RootState, T>, equalityFn?: EqualityChecker<T>): T;
+/**
+ * Executes a callback before render in a shared frame loop.
+ * Can order effects with render priority or manually render with a positive priority.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe
+ */
+export declare function useFrame(callback: RenderCallback, renderPriority?: number): null;
+/**
+ * Returns a node graph of an object with named nodes & materials.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usegraph
+ */
+export declare function useGraph(object: THREE.Object3D): ObjectMap;
+declare type GLTFLike = {
+    scene: THREE.Object3D;
+};
+/**
+ * Synchronously loads and caches assets with a three loader.
+ *
+ * Note: this hook's caller must be wrapped with `React.Suspense`
+ * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#useloader
+ */
+export declare function useLoader<T, U extends string | string[], L extends LoaderProto<T>, R = LoaderReturnType<T, L>>(Proto: L, input: U, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void): U extends any[] ? BranchingReturn<R, GLTFLike, R & ObjectMap>[] : BranchingReturn<R, GLTFLike, R & ObjectMap>;
+export declare namespace useLoader {
+    var preload: <T, U extends string | string[], L extends LoaderProto<T>>(Proto: L, input: U, extensions?: Extensions<L> | undefined) => undefined;
+    var clear: <T, U extends string | string[], L extends LoaderProto<T>>(Proto: L, input: U) => void;
+}
+export {};

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

@@ -0,0 +1,94 @@
+/// <reference types="offscreencanvas" />
+import * as THREE from 'three';
+import * as React from 'react';
+import { UseBoundStore } from 'zustand';
+import * as ReactThreeFiber from '../three-types';
+import { Renderer, context, RootState, Size, Dpr, Performance, PrivateKeys } from './store';
+import { extend, Root } from './renderer';
+import { addEffect, addAfterEffect, addTail, flushGlobalEffects, Invalidate, Advance } from './loop';
+import { EventManager, ComputeFunction } from './events';
+import { dispose, getRootState, Camera, buildGraph } from './utils';
+import type { Properties } from '../three-types';
+declare type Canvas = HTMLCanvasElement | OffscreenCanvas;
+declare const roots: Map<Canvas, Root>;
+declare const invalidate: Invalidate, advance: Advance;
+declare const reconciler: import("react-reconciler").Reconciler<UseBoundStore<RootState, import("zustand").StoreApi<RootState>>, import("./renderer").Instance, void, import("./renderer").Instance, import("./renderer").Instance>, applyProps: typeof import("./utils").applyProps;
+declare type GLProps = Renderer | ((canvas: Canvas) => Renderer) | Partial<Properties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters> | undefined;
+export declare type RenderProps<TCanvas extends Canvas> = {
+    /** A threejs renderer instance or props that go into the default renderer */
+    gl?: GLProps;
+    /** Dimensions to fit the renderer to. Will measure canvas dimensions if omitted */
+    size?: Size;
+    /**
+     * Enables shadows (by default PCFsoft). Can accept `gl.shadowMap` options for fine-tuning,
+     * but also strings: 'basic' | 'percentage' | 'soft' | 'variance'.
+     * @see https://threejs.org/docs/#api/en/renderers/WebGLRenderer.shadowMap
+     */
+    shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<THREE.WebGLShadowMap>;
+    /**
+     * Disables three r139 color management.
+     * @see https://threejs.org/docs/#manual/en/introduction/Color-management
+     */
+    legacy?: boolean;
+    /** Switch off automatic sRGB color space and gamma correction */
+    linear?: boolean;
+    /** Use `THREE.NoToneMapping` instead of `THREE.ACESFilmicToneMapping` */
+    flat?: boolean;
+    /** Creates an orthographic camera */
+    orthographic?: boolean;
+    /**
+     * R3F's render mode. Set to `demand` to only render on state change or `never` to take control.
+     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#on-demand-rendering
+     */
+    frameloop?: 'always' | 'demand' | 'never';
+    /**
+     * R3F performance options for adaptive performance.
+     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#movement-regression
+     */
+    performance?: Partial<Omit<Performance, 'regress'>>;
+    /** Target pixel ratio. Can clamp between a range: `[min, max]` */
+    dpr?: Dpr;
+    /** Props that go into the default raycaster */
+    raycaster?: Partial<THREE.Raycaster>;
+    /** A `THREE.Scene` instance or props that go into the default scene */
+    scene?: THREE.Scene | Partial<ReactThreeFiber.Object3DNode<THREE.Scene, typeof THREE.Scene>>;
+    /** A `THREE.Camera` instance or props that go into the default camera */
+    camera?: (Camera | Partial<ReactThreeFiber.Object3DNode<THREE.Camera, typeof THREE.Camera> & ReactThreeFiber.Object3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera> & ReactThreeFiber.Object3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>>) & {
+        /** Flags the camera as manual, putting projection into your own hands */
+        manual?: boolean;
+    };
+    /** An R3F event manager to manage elements' pointer events */
+    events?: (store: UseBoundStore<RootState>) => EventManager<HTMLElement>;
+    /** Callback after the canvas has rendered (but not yet committed) */
+    onCreated?: (state: RootState) => void;
+    /** Response for pointer clicks that have missed any target */
+    onPointerMissed?: (event: MouseEvent) => void;
+};
+export declare type ReconcilerRoot<TCanvas extends Canvas> = {
+    configure: (config?: RenderProps<TCanvas>) => ReconcilerRoot<TCanvas>;
+    render: (element: React.ReactNode) => UseBoundStore<RootState>;
+    unmount: () => void;
+};
+declare function createRoot<TCanvas extends Canvas>(canvas: TCanvas): ReconcilerRoot<TCanvas>;
+declare function render<TCanvas extends Canvas>(children: React.ReactNode, canvas: TCanvas, config: RenderProps<TCanvas>): UseBoundStore<RootState>;
+declare function unmountComponentAtNode<TCanvas extends Canvas>(canvas: TCanvas, callback?: (canvas: TCanvas) => void): void;
+export declare type InjectState = Partial<Omit<RootState, PrivateKeys> & {
+    events?: {
+        enabled?: boolean;
+        priority?: number;
+        compute?: ComputeFunction;
+        connected?: any;
+    };
+    size?: Size;
+}>;
+declare function createPortal(children: React.ReactNode, container: THREE.Object3D, state?: InjectState): JSX.Element;
+/**
+ * Force React to flush any updates inside the provided callback synchronously and immediately.
+ * All the same caveats documented for react-dom's `flushSync` apply here (see https://react.dev/reference/react-dom/flushSync).
+ * Nevertheless, sometimes one needs to render synchronously, for example to keep DOM and 3D changes in lock-step without
+ * having to revert to a non-React solution.
+ */
+declare function flushSync<R>(fn: () => R): R;
+declare const act: any;
+export * from './hooks';
+export { context, render, createRoot, unmountComponentAtNode, createPortal, reconciler, applyProps, dispose, invalidate, advance, extend, addEffect, addAfterEffect, addTail, flushGlobalEffects, flushSync, getRootState, act, buildGraph, roots as _roots, };

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

@@ -0,0 +1,38 @@
+import { Root } from './renderer';
+import { RootState } from './store';
+import { _XRFrame } from './utils';
+export declare type GlobalRenderCallback = (timeStamp: number) => void;
+/**
+ * Adds a global render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
+ */
+export declare const addEffect: (callback: GlobalRenderCallback) => () => void;
+/**
+ * Adds a global after-render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
+ */
+export declare const addAfterEffect: (callback: GlobalRenderCallback) => () => void;
+/**
+ * Adds a global callback which is called when rendering stops.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
+ */
+export declare const addTail: (callback: GlobalRenderCallback) => () => void;
+export declare type GlobalEffectType = 'before' | 'after' | 'tail';
+export declare function flushGlobalEffects(type: GlobalEffectType, timestamp: number): void;
+export declare type Invalidate = (state?: RootState, frames?: number) => void;
+export declare type Advance = (timestamp: number, runGlobalEffects?: boolean, state?: RootState, frame?: _XRFrame) => void;
+interface Loop {
+    loop: (timestamp: number) => void;
+    /**
+     * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.
+     * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate
+     */
+    invalidate: Invalidate;
+    /**
+     * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop="never"`.
+     * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
+     */
+    advance: Advance;
+}
+export declare function createLoop<TCanvas>(roots: Map<TCanvas, Root>): Loop;
+export {};

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

@@ -0,0 +1,58 @@
+import * as THREE from 'three';
+import { UseBoundStore } from 'zustand';
+import Reconciler from 'react-reconciler';
+import { prepare, applyProps } from './utils';
+import { RootState } from './store';
+import { EventHandlers } from './events';
+export declare type Root = {
+    fiber: Reconciler.FiberRoot;
+    store: UseBoundStore<RootState>;
+};
+export declare type LocalState = {
+    type: string;
+    root: UseBoundStore<RootState>;
+    objects: Instance[];
+    parent: Instance | null;
+    primitive?: boolean;
+    eventCount: number;
+    handlers: Partial<EventHandlers>;
+    attach?: AttachType;
+    previousAttach: any;
+    memoizedProps: {
+        [key: string]: any;
+    };
+    autoRemovedBeforeAppend?: boolean;
+};
+export declare type AttachFnType = (parent: Instance, self: Instance) => () => void;
+export declare type AttachType = string | AttachFnType;
+export declare type BaseInstance = Omit<THREE.Object3D, 'children' | 'attach' | 'add' | 'remove' | 'raycast'> & {
+    __r3f: LocalState;
+    children: Instance[];
+    remove: (...object: Instance[]) => Instance;
+    add: (...object: Instance[]) => Instance;
+    raycast?: (raycaster: THREE.Raycaster, intersects: THREE.Intersection[]) => void;
+};
+export declare type Instance = BaseInstance & {
+    [key: string]: any;
+};
+export declare type InstanceProps = {
+    [key: string]: unknown;
+} & {
+    args?: any[];
+    object?: object;
+    visible?: boolean;
+    dispose?: null;
+    attach?: AttachType;
+};
+interface Catalogue {
+    [name: string]: {
+        new (...args: any): Instance;
+    };
+}
+export declare const catalogue: Catalogue;
+declare const extend: (objects: object) => void;
+declare function createRenderer<TCanvas>(_roots: Map<TCanvas, Root>, _getEventPriority?: () => any): {
+    reconciler: Reconciler.Reconciler<UseBoundStore<RootState, import("zustand").StoreApi<RootState>>, Instance, void, Instance, Instance>;
+    applyProps: typeof applyProps;
+};
+export { prepare, createRenderer, extend };

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

@@ -0,0 +1,138 @@
+import * as THREE from 'three';
+import * as React from 'react';
+import { GetState, SetState, StoreApi, UseBoundStore } from 'zustand';
+import { DomEvent, EventManager, PointerCaptureTarget, ThreeEvent } from './events';
+import { _XRFrame, Camera } from './utils';
+import { Advance, Invalidate } from './loop';
+export declare const privateKeys: readonly ["set", "get", "setSize", "setFrameloop", "setDpr", "events", "invalidate", "advance", "size", "viewport"];
+export declare type PrivateKeys = typeof privateKeys[number];
+export interface Intersection extends THREE.Intersection {
+    eventObject: THREE.Object3D;
+}
+export declare type Subscription = {
+    ref: React.MutableRefObject<RenderCallback>;
+    priority: number;
+    store: UseBoundStore<RootState, StoreApi<RootState>>;
+};
+export declare type Dpr = number | [min: number, max: number];
+export declare type Size = {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+    /** @deprecated `updateStyle` is now disabled for OffscreenCanvas and will be removed in v9. */
+    updateStyle?: boolean;
+};
+export declare type Viewport = Size & {
+    /** The initial pixel ratio */
+    initialDpr: number;
+    /** Current pixel ratio */
+    dpr: number;
+    /** size.width / viewport.width */
+    factor: number;
+    /** Camera distance */
+    distance: number;
+    /** Camera aspect ratio: width / height */
+    aspect: number;
+};
+export declare type RenderCallback = (state: RootState, delta: number, frame?: _XRFrame) => void;
+export declare type Performance = {
+    /** Current performance normal, between min and max */
+    current: number;
+    /** How low the performance can go, between 0 and max */
+    min: number;
+    /** How high the performance can go, between min and max */
+    max: number;
+    /** Time until current returns to max in ms */
+    debounce: number;
+    /** Sets current to min, puts the system in regression */
+    regress: () => void;
+};
+export declare type Renderer = {
+    render: (scene: THREE.Scene, camera: THREE.Camera) => any;
+};
+export declare const isRenderer: (def: any) => boolean;
+export declare type InternalState = {
+    active: boolean;
+    priority: number;
+    frames: number;
+    lastEvent: React.MutableRefObject<DomEvent | null>;
+    interaction: THREE.Object3D[];
+    hovered: Map<string, ThreeEvent<DomEvent>>;
+    subscribers: Subscription[];
+    capturedMap: Map<number, Map<THREE.Object3D, PointerCaptureTarget>>;
+    initialClick: [x: number, y: number];
+    initialHits: THREE.Object3D[];
+    subscribe: (callback: React.MutableRefObject<RenderCallback>, priority: number, store: UseBoundStore<RootState, StoreApi<RootState>>) => () => void;
+};
+export declare type RootState = {
+    /** Set current state */
+    set: SetState<RootState>;
+    /** Get current state */
+    get: GetState<RootState>;
+    /** The instance of the renderer */
+    gl: THREE.WebGLRenderer;
+    /** Default camera */
+    camera: Camera & {
+        manual?: boolean;
+    };
+    /** Default scene */
+    scene: THREE.Scene;
+    /** Default raycaster */
+    raycaster: THREE.Raycaster;
+    /** Default clock */
+    clock: THREE.Clock;
+    /** Event layer interface, contains the event handler and the node they're connected to */
+    events: EventManager<any>;
+    /** XR interface */
+    xr: {
+        connect: () => void;
+        disconnect: () => void;
+    };
+    /** Currently used controls */
+    controls: THREE.EventDispatcher | null;
+    /** Normalized event coordinates */
+    pointer: THREE.Vector2;
+    /** @deprecated Normalized event coordinates, use "pointer" instead! */
+    mouse: THREE.Vector2;
+    legacy: boolean;
+    /** Shortcut to gl.outputColorSpace = THREE.LinearSRGBColorSpace */
+    linear: boolean;
+    /** Shortcut to gl.toneMapping = NoTonemapping */
+    flat: boolean;
+    /** Render loop flags */
+    frameloop: 'always' | 'demand' | 'never';
+    /** Adaptive performance interface */
+    performance: Performance;
+    /** Reactive pixel-size of the canvas */
+    size: Size;
+    /** Reactive size of the viewport in threejs units */
+    viewport: Viewport & {
+        getCurrentViewport: (camera?: Camera, target?: THREE.Vector3 | Parameters<THREE.Vector3['set']>, size?: Size) => Omit<Viewport, 'dpr' | 'initialDpr'>;
+    };
+    /** Flags the canvas for render, but doesn't render in itself */
+    invalidate: (frames?: number) => void;
+    /** Advance (render) one step */
+    advance: (timestamp: number, runGlobalEffects?: boolean) => void;
+    /** Shortcut to setting the event layer */
+    setEvents: (events: Partial<EventManager<any>>) => void;
+    /**
+     * Shortcut to manual sizing
+     */
+    setSize: (width: number, height: number, 
+    /** @deprecated `updateStyle` is now disabled for OffscreenCanvas and will be removed in v9. */
+    updateStyle?: boolean, top?: number, left?: number) => void;
+    /** Shortcut to manual setting the pixel ratio */
+    setDpr: (dpr: Dpr) => void;
+    /** Shortcut to frameloop flags */
+    setFrameloop: (frameloop?: 'always' | 'demand' | 'never') => void;
+    /** When the canvas was clicked but nothing was hit */
+    onPointerMissed?: (event: MouseEvent) => void;
+    /** If this state model is layered (via createPortal) then this contains the previous layer */
+    previousRoot?: UseBoundStore<RootState, StoreApi<RootState>>;
+    /** Internals */
+    internal: InternalState;
+};
+declare const context: React.Context<UseBoundStore<RootState, StoreApi<RootState>>>;
+declare const createStore: (invalidate: Invalidate, advance: Advance) => UseBoundStore<RootState>;
+export { createStore, context };

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

@@ -0,0 +1,134 @@
+/// <reference types="webxr" />
+import * as THREE from 'three';
+import * as React from 'react';
+import { UseBoundStore } from 'zustand';
+import { AttachType, Instance, InstanceProps, LocalState } from './renderer';
+import { Dpr, Renderer, RootState, Size } from './store';
+/** @ts-ignore */
+declare type _DeprecatedXRFrame = THREE.XRFrame;
+/** @ts-ignore */
+export declare type _XRFrame = THREE.WebGLRenderTargetOptions extends {
+    samples?: number;
+} ? XRFrame : _DeprecatedXRFrame;
+/**
+ * Returns `true` with correct TS type inference if an object has a configurable color space (since r152).
+ */
+export declare const hasColorSpace: <T extends object | Renderer | THREE.Texture, P = T extends Renderer ? {
+    outputColorSpace: string;
+} : {
+    colorSpace: string;
+}>(object: T) => object is T & P;
+export declare type ColorManagementRepresentation = {
+    enabled: boolean | never;
+} | {
+    legacyMode: boolean | never;
+};
+/**
+ * The current THREE.ColorManagement instance, if present.
+ */
+export declare const getColorManagement: () => ColorManagementRepresentation | null;
+export declare type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
+export declare const isOrthographicCamera: (def: Camera) => def is THREE.OrthographicCamera;
+export declare const isRef: (obj: any) => obj is React.MutableRefObject<unknown>;
+/**
+ * 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.MutableRefObject<T>;
+export declare type SetBlock = false | Promise<null> | null;
+export declare type UnblockProps = {
+    set: React.Dispatch<React.SetStateAction<SetBlock>>;
+    children: React.ReactNode;
+};
+export declare function Block({ set }: Omit<UnblockProps, 'children'>): null;
+export declare class ErrorBoundary extends React.Component<{
+    set: React.Dispatch<Error | undefined>;
+    children: React.ReactNode;
+}, {
+    error: boolean;
+}> {
+    state: {
+        error: boolean;
+    };
+    static getDerivedStateFromError: () => {
+        error: boolean;
+    };
+    componentDidCatch(err: Error): void;
+    render(): React.ReactNode;
+}
+export declare const DEFAULT = "__default";
+export declare const DEFAULTS: Map<any, any>;
+export declare type DiffSet = {
+    memoized: {
+        [key: string]: any;
+    };
+    changes: [key: string, value: unknown, isEvent: boolean, keys: string[]][];
+};
+export declare const isDiffSet: (def: any) => def is DiffSet;
+export declare type ClassConstructor = {
+    new (): void;
+};
+export declare type ObjectMap = {
+    nodes: {
+        [name: string]: THREE.Object3D;
+    };
+    materials: {
+        [name: string]: THREE.Material;
+    };
+};
+export declare function calculateDpr(dpr: Dpr): number;
+/**
+ * Returns instance root state
+ */
+export declare const getRootState: (obj: THREE.Object3D) => RootState | undefined;
+/**
+ * Returns the instances initial (outmost) root
+ */
+export declare function findInitialRoot(child: Instance): UseBoundStore<RootState, import("zustand").StoreApi<RootState>>;
+export declare type 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;
+    arr: (a: any) => boolean;
+    equ(a: any, b: any, { arrays, objects, strict }?: EquConfig): boolean;
+};
+/**
+ * Collects nodes and materials from a THREE.Object3D.
+ */
+export declare function buildGraph(object: THREE.Object3D): ObjectMap;
+export declare function dispose<TObj extends {
+    dispose?: () => void;
+    type?: string;
+    [key: string]: any;
+}>(obj: TObj): void;
+export declare function prepare<T = THREE.Object3D>(object: T, state?: Partial<LocalState>): T;
+export declare function attach(parent: Instance, child: Instance, type: AttachType): void;
+export declare function detach(parent: Instance, child: Instance, type: AttachType): void;
+declare type MaybeInstance = Omit<Instance, '__r3f'> & {
+    __r3f?: LocalState;
+};
+export declare function diffProps(instance: MaybeInstance, { children: cN, key: kN, ref: rN, ...props }: InstanceProps, { children: cP, key: kP, ref: rP, ...previous }?: InstanceProps, remove?: boolean): DiffSet;
+export declare function applyProps(instance: MaybeInstance, data: InstanceProps | DiffSet): MaybeInstance;
+export declare function invalidateInstance(instance: MaybeInstance): void;
+export declare function updateInstance(instance: MaybeInstance): void;
+export declare function updateCamera(camera: Camera & {
+    manual?: boolean;
+}, size: Size): void;
+export {};

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

@@ -0,0 +1,12 @@
+export * from './three-types';
+import * as ReactThreeFiber from './three-types';
+export { ReactThreeFiber };
+export type { BaseInstance, LocalState } from './core/renderer';
+export type { Intersection, Subscription, Dpr, Size, Viewport, RenderCallback, Performance, RootState, } from './core/store';
+export type { ThreeEvent, Events, EventManager, ComputeFunction } from './core/events';
+export { createEvents } from './core/events';
+export type { ObjectMap, Camera } from './core/utils';
+export * from './web/Canvas';
+export { createPointerEvents as events, createPointerEvents } from './web/events';
+export type { GlobalRenderCallback, GlobalEffectType } from './core/loop';
+export * from './core';

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

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { View, type ViewProps, type ViewStyle } from 'react-native';
+import { RenderProps } from '../core';
+export interface CanvasProps extends Omit<RenderProps<HTMLCanvasElement>, 'size' | 'dpr'>, ViewProps {
+    children: React.ReactNode;
+    style?: ViewStyle;
+}
+export interface Props extends CanvasProps {
+}
+/**
+ * A native canvas which accepts threejs elements as children.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/canvas
+ */
+export declare const Canvas: React.ForwardRefExoticComponent<Props & React.RefAttributes<View>>;

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

@@ -0,0 +1,5 @@
+import { UseBoundStore } from 'zustand';
+import { RootState } from '../core/store';
+import { EventManager } from '../core/events';
+/** Default R3F event manager for react-native */
+export declare function createTouchEvents(store: UseBoundStore<RootState>): EventManager<HTMLElement>;

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

@@ -0,0 +1 @@
+export declare function polyfills(): void;

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

@@ -0,0 +1,13 @@
+export * from './three-types';
+import * as ReactThreeFiber from './three-types';
+export { ReactThreeFiber };
+export type { BaseInstance, LocalState } from './core/renderer';
+export type { Intersection, Subscription, Dpr, Size, Viewport, RenderCallback, Performance, RootState, } from './core/store';
+export type { ThreeEvent, Events, EventManager, ComputeFunction } from './core/events';
+export { createEvents } from './core/events';
+export type { ObjectMap, Camera } from './core/utils';
+export * from './native/Canvas';
+export { createTouchEvents as events } from './native/events';
+export { createPointerEvents } from './web/events';
+export type { GlobalRenderCallback, GlobalEffectType } from './core/loop';
+export * from './core';

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

@@ -0,0 +1,393 @@
+import * as THREE from 'three';
+import { EventHandlers } from './core/events';
+import { AttachType } from './core/renderer';
+export declare type Properties<T> = Pick<T, {
+    [K in keyof T]: T[K] extends (_: any) => any ? never : K;
+}[keyof T]>;
+export declare type NonFunctionKeys<T> = {
+    [K in keyof T]-?: T[K] extends Function ? never : K;
+}[keyof T];
+export declare type Overwrite<T, O> = Omit<T, NonFunctionKeys<O>> & O;
+/**
+ * If **T** contains a constructor, @see ConstructorParameters must be used, otherwise **T**.
+ */
+declare type Args<T> = T extends new (...args: any) => any ? ConstructorParameters<T> : T;
+export declare type Euler = THREE.Euler | Parameters<THREE.Euler['set']>;
+export declare type Matrix4 = THREE.Matrix4 | Parameters<THREE.Matrix4['set']> | Readonly<THREE.Matrix4['set']>;
+/**
+ * Turn an implementation of THREE.Vector in to the type that an r3f component would accept as a prop.
+ */
+declare type VectorLike<VectorClass extends THREE.Vector2 | THREE.Vector3 | THREE.Vector4> = VectorClass | Parameters<VectorClass['set']> | Readonly<Parameters<VectorClass['set']>> | Parameters<VectorClass['setScalar']>[0];
+export declare type Vector2 = VectorLike<THREE.Vector2>;
+export declare type Vector3 = VectorLike<THREE.Vector3>;
+export declare type Vector4 = VectorLike<THREE.Vector4>;
+export declare type Color = ConstructorParameters<typeof THREE.Color> | THREE.Color | number | string;
+export declare type ColorArray = typeof THREE.Color | [color: THREE.ColorRepresentation];
+export declare type Layers = THREE.Layers | Parameters<THREE.Layers['set']>[0];
+export declare type Quaternion = THREE.Quaternion | Parameters<THREE.Quaternion['set']>;
+export declare type AttachCallback = string | ((child: any, parentInstance: any) => void);
+export interface NodeProps<T, P> {
+    attach?: AttachType;
+    /** Constructor arguments */
+    args?: Args<P>;
+    children?: React.ReactNode;
+    ref?: React.Ref<T>;
+    key?: React.Key;
+    onUpdate?: (self: T) => void;
+}
+export declare type ExtendedColors<T> = {
+    [K in keyof T]: T[K] extends THREE.Color | undefined ? Color : T[K];
+};
+export declare type Node<T, P> = ExtendedColors<Overwrite<Partial<T>, NodeProps<T, P>>>;
+export declare type Object3DNode<T, P> = Overwrite<Node<T, P>, {
+    position?: Vector3;
+    up?: Vector3;
+    scale?: Vector3;
+    rotation?: Euler;
+    matrix?: Matrix4;
+    quaternion?: Quaternion;
+    layers?: Layers;
+    dispose?: (() => void) | null;
+}> & EventHandlers;
+export declare type BufferGeometryNode<T extends THREE.BufferGeometry, P> = Node<T, P>;
+export declare type MaterialNode<T extends THREE.Material, P> = Node<T, P>;
+export declare type LightNode<T extends THREE.Light, P> = Object3DNode<T, P>;
+export declare type Object3DProps = Object3DNode<THREE.Object3D, typeof THREE.Object3D>;
+export declare type AudioListenerProps = Object3DNode<THREE.AudioListener, typeof THREE.AudioListener>;
+export declare type PositionalAudioProps = Object3DNode<THREE.PositionalAudio, typeof THREE.PositionalAudio>;
+export declare type MeshProps = Object3DNode<THREE.Mesh, typeof THREE.Mesh>;
+export declare type InstancedMeshProps = Object3DNode<THREE.InstancedMesh, typeof THREE.InstancedMesh>;
+export declare type SceneProps = Object3DNode<THREE.Scene, typeof THREE.Scene>;
+export declare type SpriteProps = Object3DNode<THREE.Sprite, typeof THREE.Sprite>;
+export declare type LODProps = Object3DNode<THREE.LOD, typeof THREE.LOD>;
+export declare type SkinnedMeshProps = Object3DNode<THREE.SkinnedMesh, typeof THREE.SkinnedMesh>;
+export declare type SkeletonProps = Object3DNode<THREE.Skeleton, typeof THREE.Skeleton>;
+export declare type BoneProps = Object3DNode<THREE.Bone, typeof THREE.Bone>;
+export declare type LineSegmentsProps = Object3DNode<THREE.LineSegments, typeof THREE.LineSegments>;
+export declare type LineLoopProps = Object3DNode<THREE.LineLoop, typeof THREE.LineLoop>;
+export declare type PointsProps = Object3DNode<THREE.Points, typeof THREE.Points>;
+export declare type GroupProps = Object3DNode<THREE.Group, typeof THREE.Group>;
+export declare type CameraProps = Object3DNode<THREE.Camera, typeof THREE.Camera>;
+export declare type PerspectiveCameraProps = Object3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera>;
+export declare type OrthographicCameraProps = Object3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>;
+export declare type CubeCameraProps = Object3DNode<THREE.CubeCamera, typeof THREE.CubeCamera>;
+export declare type ArrayCameraProps = Object3DNode<THREE.ArrayCamera, typeof THREE.ArrayCamera>;
+export declare type InstancedBufferGeometryProps = BufferGeometryNode<THREE.InstancedBufferGeometry, typeof THREE.InstancedBufferGeometry>;
+export declare type BufferGeometryProps = BufferGeometryNode<THREE.BufferGeometry, typeof THREE.BufferGeometry>;
+/** @ts-ignore */
+export declare type BoxBufferGeometryProps = BufferGeometryNode<THREE.BoxBufferGeometry, typeof THREE.BoxBufferGeometry>;
+export declare type CircleBufferGeometryProps = BufferGeometryNode<
+/** @ts-ignore */
+THREE.CircleBufferGeometry, 
+/** @ts-ignore */
+typeof THREE.CircleBufferGeometry>;
+/** @ts-ignore */
+export declare type ConeBufferGeometryProps = BufferGeometryNode<THREE.ConeBufferGeometry, typeof THREE.ConeBufferGeometry>;
+export declare type CylinderBufferGeometryProps = BufferGeometryNode<
+/** @ts-ignore */
+THREE.CylinderBufferGeometry, 
+/** @ts-ignore */
+typeof THREE.CylinderBufferGeometry>;
+export declare type DodecahedronBufferGeometryProps = BufferGeometryNode<
+/** @ts-ignore */
+THREE.DodecahedronBufferGeometry, 
+/** @ts-ignore */
+typeof THREE.DodecahedronBufferGeometry>;
+export declare type ExtrudeBufferGeometryProps = BufferGeometryNode<
+/** @ts-ignore */
+THREE.ExtrudeBufferGeometry, 
+/** @ts-ignore */
+typeof THREE.ExtrudeBufferGeometry>;
+export declare type IcosahedronBufferGeometryProps = BufferGeometryNode<
+/** @ts-ignore */
+THREE.IcosahedronBufferGeometry, 
+/** @ts-ignore */
+typeof THREE.IcosahedronBufferGeometry>;
+/** @ts-ignore */
+export declare type LatheBufferGeometryProps = BufferGeometryNode<THREE.LatheBufferGeometry, typeof THREE.LatheBufferGeometry>;
+export declare type OctahedronBufferGeometryProps = BufferGeometryNode<
+/** @ts-ignore */
+THREE.OctahedronBufferGeometry, 
+/** @ts-ignore */
+typeof THREE.OctahedronBufferGeometry>;
+/** @ts-ignore */
+export declare type PlaneBufferGeometryProps = BufferGeometryNode<THREE.PlaneBufferGeometry, typeof THREE.PlaneBufferGeometry>;
+export declare type PolyhedronBufferGeometryProps = BufferGeometryNode<
+/** @ts-ignore */
+THREE.PolyhedronBufferGeometry, 
+/** @ts-ignore */
+typeof THREE.PolyhedronBufferGeometry>;
+/** @ts-ignore */
+export declare type RingBufferGeometryProps = BufferGeometryNode<THREE.RingBufferGeometry, typeof THREE.RingBufferGeometry>;
+/** @ts-ignore */
+export declare type ShapeBufferGeometryProps = BufferGeometryNode<THREE.ShapeBufferGeometry, typeof THREE.ShapeBufferGeometry>;
+export declare type SphereBufferGeometryProps = BufferGeometryNode<
+/** @ts-ignore */
+THREE.SphereBufferGeometry, 
+/** @ts-ignore */
+typeof THREE.SphereBufferGeometry>;
+export declare type TetrahedronBufferGeometryProps = BufferGeometryNode<
+/** @ts-ignore */
+THREE.TetrahedronBufferGeometry, 
+/** @ts-ignore */
+typeof THREE.TetrahedronBufferGeometry>;
+/** @ts-ignore */
+export declare type TorusBufferGeometryProps = BufferGeometryNode<THREE.TorusBufferGeometry, typeof THREE.TorusBufferGeometry>;
+export declare type TorusKnotBufferGeometryProps = BufferGeometryNode<
+/** @ts-ignore */
+THREE.TorusKnotBufferGeometry, 
+/** @ts-ignore */
+typeof THREE.TorusKnotBufferGeometry>;
+/** @ts-ignore */
+export declare type TubeBufferGeometryProps = BufferGeometryNode<THREE.TubeBufferGeometry, typeof THREE.TubeBufferGeometry>;
+export declare type WireframeGeometryProps = BufferGeometryNode<THREE.WireframeGeometry, typeof THREE.WireframeGeometry>;
+export declare type TetrahedronGeometryProps = BufferGeometryNode<THREE.TetrahedronGeometry, typeof THREE.TetrahedronGeometry>;
+export declare type OctahedronGeometryProps = BufferGeometryNode<THREE.OctahedronGeometry, typeof THREE.OctahedronGeometry>;
+export declare type IcosahedronGeometryProps = BufferGeometryNode<THREE.IcosahedronGeometry, typeof THREE.IcosahedronGeometry>;
+export declare type DodecahedronGeometryProps = BufferGeometryNode<THREE.DodecahedronGeometry, typeof THREE.DodecahedronGeometry>;
+export declare type PolyhedronGeometryProps = BufferGeometryNode<THREE.PolyhedronGeometry, typeof THREE.PolyhedronGeometry>;
+export declare type TubeGeometryProps = BufferGeometryNode<THREE.TubeGeometry, typeof THREE.TubeGeometry>;
+export declare type TorusKnotGeometryProps = BufferGeometryNode<THREE.TorusKnotGeometry, typeof THREE.TorusKnotGeometry>;
+export declare type TorusGeometryProps = BufferGeometryNode<THREE.TorusGeometry, typeof THREE.TorusGeometry>;
+export declare type SphereGeometryProps = BufferGeometryNode<THREE.SphereGeometry, typeof THREE.SphereGeometry>;
+export declare type RingGeometryProps = BufferGeometryNode<THREE.RingGeometry, typeof THREE.RingGeometry>;
+export declare type PlaneGeometryProps = BufferGeometryNode<THREE.PlaneGeometry, typeof THREE.PlaneGeometry>;
+export declare type LatheGeometryProps = BufferGeometryNode<THREE.LatheGeometry, typeof THREE.LatheGeometry>;
+export declare type ShapeGeometryProps = BufferGeometryNode<THREE.ShapeGeometry, typeof THREE.ShapeGeometry>;
+export declare type ExtrudeGeometryProps = BufferGeometryNode<THREE.ExtrudeGeometry, typeof THREE.ExtrudeGeometry>;
+export declare type EdgesGeometryProps = BufferGeometryNode<THREE.EdgesGeometry, typeof THREE.EdgesGeometry>;
+export declare type ConeGeometryProps = BufferGeometryNode<THREE.ConeGeometry, typeof THREE.ConeGeometry>;
+export declare type CylinderGeometryProps = BufferGeometryNode<THREE.CylinderGeometry, typeof THREE.CylinderGeometry>;
+export declare type CircleGeometryProps = BufferGeometryNode<THREE.CircleGeometry, typeof THREE.CircleGeometry>;
+export declare type BoxGeometryProps = BufferGeometryNode<THREE.BoxGeometry, typeof THREE.BoxGeometry>;
+export declare type CapsuleGeometryProps = BufferGeometryNode<THREE.CapsuleGeometry, typeof THREE.CapsuleGeometry>;
+export declare type MaterialProps = MaterialNode<THREE.Material, [THREE.MaterialParameters]>;
+export declare type ShadowMaterialProps = MaterialNode<THREE.ShadowMaterial, [THREE.ShaderMaterialParameters]>;
+export declare type SpriteMaterialProps = MaterialNode<THREE.SpriteMaterial, [THREE.SpriteMaterialParameters]>;
+export declare type RawShaderMaterialProps = MaterialNode<THREE.RawShaderMaterial, [THREE.ShaderMaterialParameters]>;
+export declare type ShaderMaterialProps = MaterialNode<THREE.ShaderMaterial, [THREE.ShaderMaterialParameters]>;
+export declare type PointsMaterialProps = MaterialNode<THREE.PointsMaterial, [THREE.PointsMaterialParameters]>;
+export declare type MeshPhysicalMaterialProps = MaterialNode<THREE.MeshPhysicalMaterial, [THREE.MeshPhysicalMaterialParameters]>;
+export declare type MeshStandardMaterialProps = MaterialNode<THREE.MeshStandardMaterial, [THREE.MeshStandardMaterialParameters]>;
+export declare type MeshPhongMaterialProps = MaterialNode<THREE.MeshPhongMaterial, [THREE.MeshPhongMaterialParameters]>;
+export declare type MeshToonMaterialProps = MaterialNode<THREE.MeshToonMaterial, [THREE.MeshToonMaterialParameters]>;
+export declare type MeshNormalMaterialProps = MaterialNode<THREE.MeshNormalMaterial, [THREE.MeshNormalMaterialParameters]>;
+export declare type MeshLambertMaterialProps = MaterialNode<THREE.MeshLambertMaterial, [THREE.MeshLambertMaterialParameters]>;
+export declare type MeshDepthMaterialProps = MaterialNode<THREE.MeshDepthMaterial, [THREE.MeshDepthMaterialParameters]>;
+export declare type MeshDistanceMaterialProps = MaterialNode<THREE.MeshDistanceMaterial, [THREE.MeshDistanceMaterialParameters]>;
+export declare type MeshBasicMaterialProps = MaterialNode<THREE.MeshBasicMaterial, [THREE.MeshBasicMaterialParameters]>;
+export declare type MeshMatcapMaterialProps = MaterialNode<THREE.MeshMatcapMaterial, [THREE.MeshMatcapMaterialParameters]>;
+export declare type LineDashedMaterialProps = MaterialNode<THREE.LineDashedMaterial, [THREE.LineDashedMaterialParameters]>;
+export declare type LineBasicMaterialProps = MaterialNode<THREE.LineBasicMaterial, [THREE.LineBasicMaterialParameters]>;
+export declare type PrimitiveProps = {
+    object: object;
+} & {
+    [properties: string]: any;
+};
+export declare type LightProps = LightNode<THREE.Light, typeof THREE.Light>;
+export declare type SpotLightShadowProps = Node<THREE.SpotLightShadow, typeof THREE.SpotLightShadow>;
+export declare type SpotLightProps = LightNode<THREE.SpotLight, typeof THREE.SpotLight>;
+export declare type PointLightProps = LightNode<THREE.PointLight, typeof THREE.PointLight>;
+export declare type RectAreaLightProps = LightNode<THREE.RectAreaLight, typeof THREE.RectAreaLight>;
+export declare type HemisphereLightProps = LightNode<THREE.HemisphereLight, typeof THREE.HemisphereLight>;
+export declare type DirectionalLightShadowProps = Node<THREE.DirectionalLightShadow, typeof THREE.DirectionalLightShadow>;
+export declare type DirectionalLightProps = LightNode<THREE.DirectionalLight, typeof THREE.DirectionalLight>;
+export declare type AmbientLightProps = LightNode<THREE.AmbientLight, typeof THREE.AmbientLight>;
+export declare type LightShadowProps = Node<THREE.LightShadow, typeof THREE.LightShadow>;
+/** @ts-ignore */
+export declare type AmbientLightProbeProps = LightNode<THREE.AmbientLightProbe, typeof THREE.AmbientLightProbe>;
+/** @ts-ignore */
+export declare type HemisphereLightProbeProps = LightNode<THREE.HemisphereLightProbe, typeof THREE.HemisphereLightProbe>;
+export declare type LightProbeProps = LightNode<THREE.LightProbe, typeof THREE.LightProbe>;
+export declare type SpotLightHelperProps = Object3DNode<THREE.SpotLightHelper, typeof THREE.SpotLightHelper>;
+export declare type SkeletonHelperProps = Object3DNode<THREE.SkeletonHelper, typeof THREE.SkeletonHelper>;
+export declare type PointLightHelperProps = Object3DNode<THREE.PointLightHelper, typeof THREE.PointLightHelper>;
+export declare type HemisphereLightHelperProps = Object3DNode<THREE.HemisphereLightHelper, typeof THREE.HemisphereLightHelper>;
+export declare type GridHelperProps = Object3DNode<THREE.GridHelper, typeof THREE.GridHelper>;
+export declare type PolarGridHelperProps = Object3DNode<THREE.PolarGridHelper, typeof THREE.PolarGridHelper>;
+export declare type DirectionalLightHelperProps = Object3DNode<THREE.DirectionalLightHelper, typeof THREE.DirectionalLightHelper>;
+export declare type CameraHelperProps = Object3DNode<THREE.CameraHelper, typeof THREE.CameraHelper>;
+export declare type BoxHelperProps = Object3DNode<THREE.BoxHelper, typeof THREE.BoxHelper>;
+export declare type Box3HelperProps = Object3DNode<THREE.Box3Helper, typeof THREE.Box3Helper>;
+export declare type PlaneHelperProps = Object3DNode<THREE.PlaneHelper, typeof THREE.PlaneHelper>;
+export declare type ArrowHelperProps = Object3DNode<THREE.ArrowHelper, typeof THREE.ArrowHelper>;
+export declare type AxesHelperProps = Object3DNode<THREE.AxesHelper, typeof THREE.AxesHelper>;
+export declare type TextureProps = Node<THREE.Texture, typeof THREE.Texture>;
+export declare type VideoTextureProps = Node<THREE.VideoTexture, typeof THREE.VideoTexture>;
+export declare type DataTextureProps = Node<THREE.DataTexture, typeof THREE.DataTexture>;
+/** @ts-ignore */
+export declare type DataTexture3DProps = Node<THREE.DataTexture3D, typeof THREE.DataTexture3D>;
+export declare type CompressedTextureProps = Node<THREE.CompressedTexture, typeof THREE.CompressedTexture>;
+export declare type CubeTextureProps = Node<THREE.CubeTexture, typeof THREE.CubeTexture>;
+export declare type CanvasTextureProps = Node<THREE.CanvasTexture, typeof THREE.CanvasTexture>;
+export declare type DepthTextureProps = Node<THREE.DepthTexture, typeof THREE.DepthTexture>;
+export declare type RaycasterProps = Node<THREE.Raycaster, typeof THREE.Raycaster>;
+export declare type Vector2Props = Node<THREE.Vector2, typeof THREE.Vector2>;
+export declare type Vector3Props = Node<THREE.Vector3, typeof THREE.Vector3>;
+export declare type Vector4Props = Node<THREE.Vector4, typeof THREE.Vector4>;
+export declare type EulerProps = Node<THREE.Euler, typeof THREE.Euler>;
+export declare type Matrix3Props = Node<THREE.Matrix3, typeof THREE.Matrix3>;
+export declare type Matrix4Props = Node<THREE.Matrix4, typeof THREE.Matrix4>;
+export declare type QuaternionProps = Node<THREE.Quaternion, typeof THREE.Quaternion>;
+export declare type BufferAttributeProps = Node<THREE.BufferAttribute, typeof THREE.BufferAttribute>;
+export declare type Float16BufferAttributeProps = Node<THREE.Float16BufferAttribute, typeof THREE.Float16BufferAttribute>;
+export declare type Float32BufferAttributeProps = Node<THREE.Float32BufferAttribute, typeof THREE.Float32BufferAttribute>;
+/** @ts-ignore */
+export declare type Float64BufferAttributeProps = Node<THREE.Float64BufferAttribute, typeof THREE.Float64BufferAttribute>;
+export declare type Int8BufferAttributeProps = Node<THREE.Int8BufferAttribute, typeof THREE.Int8BufferAttribute>;
+export declare type Int16BufferAttributeProps = Node<THREE.Int16BufferAttribute, typeof THREE.Int16BufferAttribute>;
+export declare type Int32BufferAttributeProps = Node<THREE.Int32BufferAttribute, typeof THREE.Int32BufferAttribute>;
+export declare type Uint8BufferAttributeProps = Node<THREE.Uint8BufferAttribute, typeof THREE.Uint8BufferAttribute>;
+export declare type Uint16BufferAttributeProps = Node<THREE.Uint16BufferAttribute, typeof THREE.Uint16BufferAttribute>;
+export declare type Uint32BufferAttributeProps = Node<THREE.Uint32BufferAttribute, typeof THREE.Uint32BufferAttribute>;
+export declare type InstancedBufferAttributeProps = Node<THREE.InstancedBufferAttribute, typeof THREE.InstancedBufferAttribute>;
+export declare type ColorProps = Node<THREE.Color, ColorArray>;
+export declare type FogProps = Node<THREE.Fog, typeof THREE.Fog>;
+export declare type FogExp2Props = Node<THREE.FogExp2, typeof THREE.FogExp2>;
+export declare type ShapeProps = Node<THREE.Shape, typeof THREE.Shape>;
+export interface ThreeElements {
+    object3D: Object3DProps;
+    audioListener: AudioListenerProps;
+    positionalAudio: PositionalAudioProps;
+    mesh: MeshProps;
+    instancedMesh: InstancedMeshProps;
+    scene: SceneProps;
+    sprite: SpriteProps;
+    lOD: LODProps;
+    skinnedMesh: SkinnedMeshProps;
+    skeleton: SkeletonProps;
+    bone: BoneProps;
+    lineSegments: LineSegmentsProps;
+    lineLoop: LineLoopProps;
+    points: PointsProps;
+    group: GroupProps;
+    camera: CameraProps;
+    perspectiveCamera: PerspectiveCameraProps;
+    orthographicCamera: OrthographicCameraProps;
+    cubeCamera: CubeCameraProps;
+    arrayCamera: ArrayCameraProps;
+    instancedBufferGeometry: InstancedBufferGeometryProps;
+    bufferGeometry: BufferGeometryProps;
+    boxBufferGeometry: BoxBufferGeometryProps;
+    circleBufferGeometry: CircleBufferGeometryProps;
+    coneBufferGeometry: ConeBufferGeometryProps;
+    cylinderBufferGeometry: CylinderBufferGeometryProps;
+    dodecahedronBufferGeometry: DodecahedronBufferGeometryProps;
+    extrudeBufferGeometry: ExtrudeBufferGeometryProps;
+    icosahedronBufferGeometry: IcosahedronBufferGeometryProps;
+    latheBufferGeometry: LatheBufferGeometryProps;
+    octahedronBufferGeometry: OctahedronBufferGeometryProps;
+    planeBufferGeometry: PlaneBufferGeometryProps;
+    polyhedronBufferGeometry: PolyhedronBufferGeometryProps;
+    ringBufferGeometry: RingBufferGeometryProps;
+    shapeBufferGeometry: ShapeBufferGeometryProps;
+    sphereBufferGeometry: SphereBufferGeometryProps;
+    tetrahedronBufferGeometry: TetrahedronBufferGeometryProps;
+    torusBufferGeometry: TorusBufferGeometryProps;
+    torusKnotBufferGeometry: TorusKnotBufferGeometryProps;
+    tubeBufferGeometry: TubeBufferGeometryProps;
+    wireframeGeometry: WireframeGeometryProps;
+    tetrahedronGeometry: TetrahedronGeometryProps;
+    octahedronGeometry: OctahedronGeometryProps;
+    icosahedronGeometry: IcosahedronGeometryProps;
+    dodecahedronGeometry: DodecahedronGeometryProps;
+    polyhedronGeometry: PolyhedronGeometryProps;
+    tubeGeometry: TubeGeometryProps;
+    torusKnotGeometry: TorusKnotGeometryProps;
+    torusGeometry: TorusGeometryProps;
+    sphereGeometry: SphereGeometryProps;
+    ringGeometry: RingGeometryProps;
+    planeGeometry: PlaneGeometryProps;
+    latheGeometry: LatheGeometryProps;
+    shapeGeometry: ShapeGeometryProps;
+    extrudeGeometry: ExtrudeGeometryProps;
+    edgesGeometry: EdgesGeometryProps;
+    coneGeometry: ConeGeometryProps;
+    cylinderGeometry: CylinderGeometryProps;
+    circleGeometry: CircleGeometryProps;
+    boxGeometry: BoxGeometryProps;
+    capsuleGeometry: CapsuleGeometryProps;
+    material: MaterialProps;
+    shadowMaterial: ShadowMaterialProps;
+    spriteMaterial: SpriteMaterialProps;
+    rawShaderMaterial: RawShaderMaterialProps;
+    shaderMaterial: ShaderMaterialProps;
+    pointsMaterial: PointsMaterialProps;
+    meshPhysicalMaterial: MeshPhysicalMaterialProps;
+    meshStandardMaterial: MeshStandardMaterialProps;
+    meshPhongMaterial: MeshPhongMaterialProps;
+    meshToonMaterial: MeshToonMaterialProps;
+    meshNormalMaterial: MeshNormalMaterialProps;
+    meshLambertMaterial: MeshLambertMaterialProps;
+    meshDepthMaterial: MeshDepthMaterialProps;
+    meshDistanceMaterial: MeshDistanceMaterialProps;
+    meshBasicMaterial: MeshBasicMaterialProps;
+    meshMatcapMaterial: MeshMatcapMaterialProps;
+    lineDashedMaterial: LineDashedMaterialProps;
+    lineBasicMaterial: LineBasicMaterialProps;
+    primitive: PrimitiveProps;
+    light: LightProps;
+    spotLightShadow: SpotLightShadowProps;
+    spotLight: SpotLightProps;
+    pointLight: PointLightProps;
+    rectAreaLight: RectAreaLightProps;
+    hemisphereLight: HemisphereLightProps;
+    directionalLightShadow: DirectionalLightShadowProps;
+    directionalLight: DirectionalLightProps;
+    ambientLight: AmbientLightProps;
+    lightShadow: LightShadowProps;
+    ambientLightProbe: AmbientLightProbeProps;
+    hemisphereLightProbe: HemisphereLightProbeProps;
+    lightProbe: LightProbeProps;
+    spotLightHelper: SpotLightHelperProps;
+    skeletonHelper: SkeletonHelperProps;
+    pointLightHelper: PointLightHelperProps;
+    hemisphereLightHelper: HemisphereLightHelperProps;
+    gridHelper: GridHelperProps;
+    polarGridHelper: PolarGridHelperProps;
+    directionalLightHelper: DirectionalLightHelperProps;
+    cameraHelper: CameraHelperProps;
+    boxHelper: BoxHelperProps;
+    box3Helper: Box3HelperProps;
+    planeHelper: PlaneHelperProps;
+    arrowHelper: ArrowHelperProps;
+    axesHelper: AxesHelperProps;
+    texture: TextureProps;
+    videoTexture: VideoTextureProps;
+    dataTexture: DataTextureProps;
+    dataTexture3D: DataTexture3DProps;
+    compressedTexture: CompressedTextureProps;
+    cubeTexture: CubeTextureProps;
+    canvasTexture: CanvasTextureProps;
+    depthTexture: DepthTextureProps;
+    raycaster: RaycasterProps;
+    vector2: Vector2Props;
+    vector3: Vector3Props;
+    vector4: Vector4Props;
+    euler: EulerProps;
+    matrix3: Matrix3Props;
+    matrix4: Matrix4Props;
+    quaternion: QuaternionProps;
+    bufferAttribute: BufferAttributeProps;
+    float16BufferAttribute: Float16BufferAttributeProps;
+    float32BufferAttribute: Float32BufferAttributeProps;
+    float64BufferAttribute: Float64BufferAttributeProps;
+    int8BufferAttribute: Int8BufferAttributeProps;
+    int16BufferAttribute: Int16BufferAttributeProps;
+    int32BufferAttribute: Int32BufferAttributeProps;
+    uint8BufferAttribute: Uint8BufferAttributeProps;
+    uint16BufferAttribute: Uint16BufferAttributeProps;
+    uint32BufferAttribute: Uint32BufferAttributeProps;
+    instancedBufferAttribute: InstancedBufferAttributeProps;
+    color: ColorProps;
+    fog: FogProps;
+    fogExp2: FogExp2Props;
+    shape: ShapeProps;
+}
+declare global {
+    namespace JSX {
+        interface IntrinsicElements extends ThreeElements {
+        }
+    }
+}
+export {};

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

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import { Options as ResizeOptions } from './use-measure';
+import { RenderProps } from '../core';
+export interface CanvasProps extends Omit<RenderProps<HTMLCanvasElement>, 'size'>, React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    /** 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.MutableRefObject<HTMLElement>;
+    /** The event prefix that is cast into canvas pointer x/y events, default: "offset" */
+    eventPrefix?: 'offset' | 'client' | 'page' | 'layer' | 'screen';
+}
+export interface Props extends CanvasProps {
+}
+/**
+ * A DOM canvas which accepts threejs elements as children.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/canvas
+ */
+export declare const Canvas: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLCanvasElement>>;

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

@@ -0,0 +1,5 @@
+import { UseBoundStore } from 'zustand';
+import { RootState } from '../core/store';
+import { EventManager } from '../core/events';
+/** Default R3F event manager for web */
+export declare function createPointerEvents(store: UseBoundStore<RootState>): EventManager<HTMLElement>;

package/dist/declarations/src/web/use-measure.d.ts

@@ -0,0 +1,34 @@
+declare type ResizeObserverCallback = (entries: any[], observer: ResizeObserver) => void;
+declare class ResizeObserver {
+    constructor(callback: ResizeObserverCallback);
+    observe(target: Element, options?: any): void;
+    unobserve(target: Element): void;
+    disconnect(): void;
+    static toString(): string;
+}
+export interface RectReadOnly {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+    [key: string]: number;
+}
+declare type HTMLOrSVGElement = HTMLElement | SVGElement;
+declare type Result = [(element: HTMLOrSVGElement | null) => void, RectReadOnly, () => void];
+export declare type Options = {
+    debounce?: number | {
+        scroll: number;
+        resize: number;
+    };
+    scroll?: boolean;
+    polyfill?: {
+        new (cb: ResizeObserverCallback): ResizeObserver;
+    };
+    offsetSize?: boolean;
+};
+export declare function useMeasure({ debounce, scroll, polyfill, offsetSize }?: Options): Result;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-three/fiber",
-  "version": "8.17.4",
+  "version": "8.17.5",
   "description": "A React renderer for Threejs",
   "keywords": [
     "react",