@react-three/fiber 9.1.1 → 9.1.3

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

@@ -1,89 +1,89 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import type { ThreeElement } from "../three-types.js";
-import { Renderer, RootState, Size, Dpr, Performance, Frameloop, RootStore } from "./store.js";
-import { Root } from "./reconciler.js";
-import { EventManager, ComputeFunction } from "./events.js";
-import { type Properties, Camera } from "./utils.js";
-interface OffscreenCanvas extends EventTarget {
-}
-export declare const _roots: Map<HTMLCanvasElement | OffscreenCanvas, Root>;
-export type DefaultGLProps = Omit<THREE.WebGLRendererParameters, 'canvas'> & {
-    canvas: HTMLCanvasElement | OffscreenCanvas;
-};
-export type GLProps = Renderer | ((defaultProps: DefaultGLProps) => Renderer) | ((defaultProps: DefaultGLProps) => Promise<Renderer>) | Partial<Properties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters>;
-export type CameraProps = (Camera | Partial<ThreeElement<typeof THREE.Camera> & ThreeElement<typeof THREE.PerspectiveCamera> & ThreeElement<typeof THREE.OrthographicCamera>>) & {
-    /** Flags the camera as manual, putting projection into your own hands */
-    manual?: boolean;
-};
-export interface RenderProps<TCanvas extends HTMLCanvasElement | OffscreenCanvas> {
-    /** 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 encoding 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?: Frameloop;
-    /**
-     * 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<THREE.Scene>;
-    /** A `THREE.Camera` instance or props that go into the default camera */
-    camera?: CameraProps;
-    /** An R3F event manager to manage elements' pointer events */
-    events?: (store: RootStore) => 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 interface ReconcilerRoot<TCanvas extends HTMLCanvasElement | OffscreenCanvas> {
-    configure: (config?: RenderProps<TCanvas>) => Promise<ReconcilerRoot<TCanvas>>;
-    render: (element: React.ReactNode) => RootStore;
-    unmount: () => void;
-}
-export declare function createRoot<TCanvas extends HTMLCanvasElement | OffscreenCanvas>(canvas: TCanvas): ReconcilerRoot<TCanvas>;
-export declare function unmountComponentAtNode<TCanvas extends HTMLCanvasElement | OffscreenCanvas>(canvas: TCanvas, callback?: (canvas: TCanvas) => void): void;
-export type InjectState = Partial<Omit<RootState, 'events'> & {
-    events?: {
-        enabled?: boolean;
-        priority?: number;
-        compute?: ComputeFunction;
-        connected?: any;
-    };
-}>;
-export declare function createPortal(children: React.ReactNode, container: THREE.Object3D, state?: InjectState): React.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.
- */
-export declare function flushSync<R>(fn: () => R): R;
-export {};
+import * as THREE from 'three';
+import * as React from 'react';
+import type { ThreeElement } from "../three-types.js";
+import { Renderer, RootState, Size, Dpr, Performance, Frameloop, RootStore } from "./store.js";
+import { Root } from "./reconciler.js";
+import { EventManager, ComputeFunction } from "./events.js";
+import { type Properties, Camera } from "./utils.js";
+interface OffscreenCanvas extends EventTarget {
+}
+export declare const _roots: Map<HTMLCanvasElement | OffscreenCanvas, Root>;
+export type DefaultGLProps = Omit<THREE.WebGLRendererParameters, 'canvas'> & {
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+};
+export type GLProps = Renderer | ((defaultProps: DefaultGLProps) => Renderer) | ((defaultProps: DefaultGLProps) => Promise<Renderer>) | Partial<Properties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters>;
+export type CameraProps = (Camera | Partial<ThreeElement<typeof THREE.Camera> & ThreeElement<typeof THREE.PerspectiveCamera> & ThreeElement<typeof THREE.OrthographicCamera>>) & {
+    /** Flags the camera as manual, putting projection into your own hands */
+    manual?: boolean;
+};
+export interface RenderProps<TCanvas extends HTMLCanvasElement | OffscreenCanvas> {
+    /** 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 encoding 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?: Frameloop;
+    /**
+     * 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<THREE.Scene>;
+    /** A `THREE.Camera` instance or props that go into the default camera */
+    camera?: CameraProps;
+    /** An R3F event manager to manage elements' pointer events */
+    events?: (store: RootStore) => 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 interface ReconcilerRoot<TCanvas extends HTMLCanvasElement | OffscreenCanvas> {
+    configure: (config?: RenderProps<TCanvas>) => Promise<ReconcilerRoot<TCanvas>>;
+    render: (element: React.ReactNode) => RootStore;
+    unmount: () => void;
+}
+export declare function createRoot<TCanvas extends HTMLCanvasElement | OffscreenCanvas>(canvas: TCanvas): ReconcilerRoot<TCanvas>;
+export declare function unmountComponentAtNode<TCanvas extends HTMLCanvasElement | OffscreenCanvas>(canvas: TCanvas, callback?: (canvas: TCanvas) => void): void;
+export type InjectState = Partial<Omit<RootState, 'events'> & {
+    events?: {
+        enabled?: boolean;
+        priority?: number;
+        compute?: ComputeFunction;
+        connected?: any;
+    };
+}>;
+export declare function createPortal(children: React.ReactNode, container: THREE.Object3D, state?: InjectState): React.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.
+ */
+export declare function flushSync<R>(fn: () => R): R;
+export {};

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

@@ -1,130 +1,130 @@
-/// <reference types="webxr" />
-import * as THREE from 'three';
-import * as React from 'react';
-import { type StoreApi } from 'zustand';
-import { type UseBoundStoreWithEqualityFn } from 'zustand/traditional';
-import type { DomEvent, EventManager, PointerCaptureTarget, ThreeEvent } from "./events.js";
-import { type Camera } from "./utils.js";
-export interface Intersection extends THREE.Intersection {
-    eventObject: THREE.Object3D;
-}
-export type Subscription = {
-    ref: React.RefObject<RenderCallback>;
-    priority: number;
-    store: RootStore;
-};
-export type Dpr = number | [min: number, max: number];
-export interface Size {
-    width: number;
-    height: number;
-    top: number;
-    left: number;
-}
-export type Frameloop = 'always' | 'demand' | 'never';
-export interface Viewport extends 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 type RenderCallback = (state: RootState, delta: number, frame?: XRFrame) => void;
-export interface 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 interface Renderer {
-    render: (scene: THREE.Scene, camera: THREE.Camera) => any;
-}
-export declare const isRenderer: (def: any) => boolean;
-export interface InternalState {
-    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[];
-    lastEvent: React.RefObject<DomEvent | null>;
-    active: boolean;
-    priority: number;
-    frames: number;
-    subscribe: (callback: React.RefObject<RenderCallback>, priority: number, store: RootStore) => () => void;
-}
-export interface XRManager {
-    connect: () => void;
-    disconnect: () => void;
-}
-export interface RootState {
-    /** Set current state */
-    set: StoreApi<RootState>['setState'];
-    /** Get current state */
-    get: StoreApi<RootState>['getState'];
-    /** The instance of the renderer */
-    gl: THREE.WebGLRenderer;
-    /** Default camera */
-    camera: Camera;
-    /** 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: XRManager;
-    /** 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: Frameloop;
-    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, top?: number, left?: number) => void;
-    /** Shortcut to manual setting the pixel ratio */
-    setDpr: (dpr: Dpr) => void;
-    /** Shortcut to setting frameloop flags */
-    setFrameloop: (frameloop: Frameloop) => 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?: RootStore;
-    /** Internals */
-    internal: InternalState;
-}
-export type RootStore = UseBoundStoreWithEqualityFn<StoreApi<RootState>>;
-export declare const context: React.Context<RootStore>;
-export declare const createStore: (invalidate: (state?: RootState, frames?: number) => void, advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState, frame?: XRFrame) => void) => RootStore;
+/// <reference types="webxr" />
+import * as THREE from 'three';
+import * as React from 'react';
+import { type StoreApi } from 'zustand';
+import { type UseBoundStoreWithEqualityFn } from 'zustand/traditional';
+import type { DomEvent, EventManager, PointerCaptureTarget, ThreeEvent } from "./events.js";
+import { type Camera } from "./utils.js";
+export interface Intersection extends THREE.Intersection {
+    eventObject: THREE.Object3D;
+}
+export type Subscription = {
+    ref: React.RefObject<RenderCallback>;
+    priority: number;
+    store: RootStore;
+};
+export type Dpr = number | [min: number, max: number];
+export interface Size {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+}
+export type Frameloop = 'always' | 'demand' | 'never';
+export interface Viewport extends 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 type RenderCallback = (state: RootState, delta: number, frame?: XRFrame) => void;
+export interface 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 interface Renderer {
+    render: (scene: THREE.Scene, camera: THREE.Camera) => any;
+}
+export declare const isRenderer: (def: any) => boolean;
+export interface InternalState {
+    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[];
+    lastEvent: React.RefObject<DomEvent | null>;
+    active: boolean;
+    priority: number;
+    frames: number;
+    subscribe: (callback: React.RefObject<RenderCallback>, priority: number, store: RootStore) => () => void;
+}
+export interface XRManager {
+    connect: () => void;
+    disconnect: () => void;
+}
+export interface RootState {
+    /** Set current state */
+    set: StoreApi<RootState>['setState'];
+    /** Get current state */
+    get: StoreApi<RootState>['getState'];
+    /** The instance of the renderer */
+    gl: THREE.WebGLRenderer;
+    /** Default camera */
+    camera: Camera;
+    /** 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: XRManager;
+    /** 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: Frameloop;
+    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, top?: number, left?: number) => void;
+    /** Shortcut to manual setting the pixel ratio */
+    setDpr: (dpr: Dpr) => void;
+    /** Shortcut to setting frameloop flags */
+    setFrameloop: (frameloop: Frameloop) => 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?: RootStore;
+    /** Internals */
+    internal: InternalState;
+}
+export type RootStore = UseBoundStoreWithEqualityFn<StoreApi<RootState>>;
+export declare const context: React.Context<RootStore>;
+export declare const createStore: (invalidate: (state?: RootState, frames?: number) => void, advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState, frame?: XRFrame) => void) => RootStore;