@react-three/fiber 9.8.1 → 9.8.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @react-three/fiber
 
+## 9.8.2
+
+### Patch Changes
+
+- Include native build output explicitly in published packages so workspace ignore rules cannot omit the React Native entry points.
+- 77406776ae0ee61a4ca73e92082929f9a54359ab: Keep pointer capture working when an object's `args` change during a drag (#3985), and request a frame when an object is removed with `frameloop="demand"` so it disappears immediately (#3976).
+- d74622ea8ed717f7212d7e19d65ff3e325508389: Fix `createPortal` memory leaks: parent subscriptions are cleaned up when a portal unmounts or is hidden by Activity (#3676), and event setters no longer retain earlier portal states (#3751). Portal state survives Activity hide/show, and parent changes made before subscribing or while hidden are applied when the subscription starts. Ports the leak fixes from v10.
+- db8fdf21fa46e3b40d2791e0ea7a684d878ae404: Only register three.js constructors as JSX intrinsic elements. Non-constructor exports such as constants and `MathUtils` were previously registered with `never` props, which collapsed the props of any `React.ElementType` to `never` once `@react-three/fiber` was imported.
+- bffddfaafbf9a5e1f749cb6612d6b1f0189b26a9: fix: follow devicePixelRatio changes when the canvas moves to another display or the page is zoomed.
+
+  Neither resizes the canvas, so nothing re-rendered it and the `dpr` prop stayed resolved against the old ratio: blurry on a denser display, four times the pixels on a coarser one. Roots now watch the ratio and re-resolve the prop the same way a re-render does. A fixed `dpr` is unaffected and never touches `matchMedia`, changes during an XR session apply once it ends, and environments without a working `matchMedia`, such as test setups with a partial mock, behave as before.
+
 ## 9.8.1
 
 ### Patch Changes

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

@@ -69,8 +69,6 @@ export interface AppliedConfiguration {
     /** The camera prop that set the current camera */
     camera?: Configuration['camera'];
 }
-/** The renderer to configure, or a promise for one from an async factory */
-export declare function createRenderer(canvas: Canvas, gl?: GLProps): Renderer | PromiseLike<Renderer>;
 /**
  * Applies the inputs that changed since the last configuration applied in full, to a root whose
  * renderer is installed. A runtime change, such as setFrameloop or an edit to gl.shadowMap, lasts
@@ -81,4 +79,13 @@ export declare function applyRootConfiguration({ store, configuration }: {
     store: RootStore;
     configuration: AppliedConfiguration;
 }, canvas: Canvas, props: Configuration): void;
+/**
+ * Moving to another display or zooming changes window.devicePixelRatio without resizing the canvas,
+ * so nothing configures the root again. Resolves the ratio the way configuration does, from the last
+ * applied dpr. Returns the function that stops following.
+ */
+export declare function followDpr(root: {
+    store: RootStore;
+    configuration: AppliedConfiguration;
+}): () => void;
 export {};

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

@@ -0,0 +1,12 @@
+/** Constructor registration and lookup for JSX elements. */
+import type * as React from 'react';
+import type { ThreeElement } from "../three-types.js";
+export type ConstructorRepresentation<T = any> = new (...args: any[]) => T;
+export interface Catalogue {
+    [name: string]: ConstructorRepresentation;
+}
+export declare const toPascalCase: (type: string) => string;
+export declare function hasConstructor(name: string): boolean;
+export declare function resolveConstructor(name: string): ConstructorRepresentation | undefined;
+export declare function extend<T extends ConstructorRepresentation>(objects: T): React.ExoticComponent<ThreeElement<T>>;
+export declare function extend<T extends Catalogue>(objects: T): void;

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

@@ -2,7 +2,8 @@ import * as THREE from 'three';
 import * as React from 'react';
 import { RootState, RenderCallback, RootStore } from "./store.js";
 import { ObjectMap } from "./utils.js";
-import type { Instance, ConstructorRepresentation } from "./reconciler.js";
+import type { Instance } from "./reconciler.js";
+import type { ConstructorRepresentation } from "./extend.js";
 /**
  * Exposes an object's {@link Instance}.
  * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#useInstanceHandle

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

@@ -3,8 +3,10 @@ export { createEvents } from "./events.js";
 export * from "./hooks.js";
 export type { GlobalRenderCallback, GlobalEffectType } from "./loop.js";
 export { flushGlobalEffects, addEffect, addAfterEffect, addTail, invalidate, advance } from "./loop.js";
-export type { AttachFnType, AttachType, ConstructorRepresentation, Catalogue, Args, InstanceProps, Instance, } from "./reconciler.js";
-export { extend, reconciler, flushSync } from "./reconciler.js";
+export type { AttachFnType, AttachType, Args, InstanceProps, Instance } from "./reconciler.js";
+export type { ConstructorRepresentation, Catalogue } from "./extend.js";
+export { extend } from "./extend.js";
+export { reconciler, flushSync } from "./reconciler.js";
 export type { GLProps, CameraProps, RenderProps } from "./configuration.js";
 export type { ReconcilerRoot } from "./root.js";
 export { _roots, createRoot, unmountComponentAtNode } from "./root.js";
@@ -14,4 +16,4 @@ export type { Subscription, Dpr, Size, Viewport, RenderCallback, Frameloop, Perf
 export { context } from "./store.js";
 export type { ObjectMap, Camera, Disposable, Act } from "./utils.js";
 export { applyProps, getRootState, dispose, act, buildGraph } from "./utils.js";
-export type { TrackedPromise } from "./promise.js";
+export type { TrackedPromise } from "./utils/promise.js";

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

@@ -1,16 +1,13 @@
 import * as THREE from 'three';
-import * as React from 'react';
 import Reconciler from '../../react-reconciler/index.js';
 import { IsAllOptional } from "./utils.js";
 import type { RootStore } from "./store.js";
 import { type EventHandlers } from "./events.js";
-import type { ThreeElement } from "../three-types.js";
+import { type ConstructorRepresentation } from "./extend.js";
+export { extend } from "./extend.js";
+export type { ConstructorRepresentation, Catalogue } from "./extend.js";
 export type AttachFnType<O = any> = (parent: any, self: O) => () => void;
 export type AttachType<O = any> = string | AttachFnType<O>;
-export type ConstructorRepresentation<T = any> = new (...args: any[]) => T;
-export interface Catalogue {
-    [name: string]: ConstructorRepresentation;
-}
 export type Args<T> = T extends ConstructorRepresentation ? T extends typeof THREE.Color ? [r: number, g: number, b: number] | [color: THREE.ColorRepresentation] : ConstructorParameters<T> : any[];
 type ArgsProp<P> = P extends ConstructorRepresentation ? IsAllOptional<ConstructorParameters<P>> extends true ? {
     args?: Args<P>;
@@ -41,8 +38,6 @@ export interface Instance<O = any> {
     previousVisible: boolean | undefined;
     isHidden: boolean;
 }
-export declare function extend<T extends ConstructorRepresentation>(objects: T): React.ExoticComponent<ThreeElement<T>>;
-export declare function extend<T extends Catalogue>(objects: T): void;
 export declare const reconciler: Reconciler.Reconciler<RootStore, Instance<any>, void, Instance<any>, never, any>;
 /**
  * Force React to flush any updates inside the provided callback synchronously and immediately.
@@ -51,4 +46,3 @@ export declare const reconciler: Reconciler.Reconciler<RootStore, Instance<any>,
  * having to revert to a non-React solution. Note: this will only flush updates within the `Canvas` root.
  */
 export declare function flushSync<R>(fn: () => R): R;
-export {};

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

@@ -0,0 +1,9 @@
+/** Renderer creation and resource release. Root lifetime decides when release is safe. */
+import * as THREE from 'three';
+import type { DefaultGLProps, GLProps } from "./configuration.js";
+import type { Renderer } from "./store.js";
+export declare const isRenderer: (def: any) => boolean;
+/** The renderer to configure, or a promise for one from an async factory */
+export declare function createRenderer(canvas: DefaultGLProps['canvas'], gl?: GLProps): Renderer | PromiseLike<Renderer>;
+/** Owned renderers are disposed. Caller-provided renderers release caches and their context. */
+export declare function releaseRenderer(gl: THREE.WebGLRenderer | undefined, owned: boolean): void | Promise<void>;

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

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import type Reconciler from '../../react-reconciler/index.js';
 import { type AppliedConfiguration, type RenderProps } from "./configuration.js";
-import { type TrackedPromise } from "./promise.js";
+import { type TrackedPromise } from "./utils/promise.js";
 import { type RootStore } from "./store.js";
 interface OffscreenCanvas extends EventTarget {
 }
@@ -14,6 +14,8 @@ export interface Root {
     configuration: AppliedConfiguration;
     /** Whether R3F built `gl` (from defaults, props or a factory) and so disposes it on unmount */
     ownsRenderer: boolean;
+    /** Stops following devicePixelRatio changes */
+    unwatchDpr?: () => void;
 }
 export declare const _roots: Map<HTMLCanvasElement | OffscreenCanvas, Root>;
 export type RootStateMachine = {

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

@@ -49,7 +49,7 @@ export interface Performance {
 export interface Renderer {
     render: (scene: THREE.Scene, camera: THREE.Camera) => any;
 }
-export declare const isRenderer: (def: any) => boolean;
+export { isRenderer } from "./renderer.js";
 export interface InternalState {
     interaction: THREE.Object3D[];
     hovered: Map<string, ThreeEvent<DomEvent>>;

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

@@ -0,0 +1,184 @@
+import * as React from 'react';
+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;
+/**
+ * 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>;
+/** Waits for a promise in a null subtree, re-rendering the caller once it settles either way. */
+export declare function useGate(): [gate: React.ReactNode, waitFor: (promise: PromiseLike<unknown>) => void];
+export type Bridge = React.FC<{
+    children?: React.ReactNode;
+}>;
+/**
+ * Bridges Context, StrictMode, and Activity visibility 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;
+        }>, nextContext: any): 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;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>, nextContext: any): void;
+    };
+    new (props: {
+        set: React.Dispatch<Error | undefined>;
+        children: React.ReactNode;
+    }, context: any): {
+        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;
+        }>, nextContext: any): 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;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>, nextContext: any): void;
+    };
+    getDerivedStateFromError: () => {
+        error: boolean;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};

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

@@ -1,7 +1,9 @@
 import * as THREE from 'three';
-import * as React from 'react';
+import type * as React from 'react';
 import { Instance } from "./reconciler.js";
 import type { Dpr, RootStore, Size } from "./store.js";
+export type { Act, Bridge, SetBlock, UnblockProps } from "./utils/react.js";
+export { act, useIsomorphicLayoutEffect, useMutableCallback, useGate, useBridge, Block, ErrorBoundary, } from "./utils/react.js";
 export type NonFunctionKeys<P> = {
     [K in keyof P]-?: P[K] extends Function ? never : K;
 }[keyof P];
@@ -16,196 +18,13 @@ export type IsAllOptional<T extends any[]> = T extends [infer First, ...infer Re
  * 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 declare const noop: () => void;
-/** Waits for a promise in a null subtree, re-rendering the caller once it settles either way. */
-export declare function useGate(): [gate: React.ReactNode, waitFor: (promise: PromiseLike<unknown>) => void];
-export type Bridge = React.FC<{
-    children?: React.ReactNode;
-}>;
-/**
- * Bridges Context, StrictMode, and Activity visibility 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;
-        }>, nextContext: any): 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;
-        }>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>, nextContext: any): void;
-    };
-    new (props: {
-        set: React.Dispatch<Error | undefined>;
-        children: React.ReactNode;
-    }, context: any): {
-        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;
-        }>, nextContext: any): 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;
-        }>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>, nextContext: any): void;
-    };
-    getDerivedStateFromError: () => {
-        error: boolean;
-    };
-    contextType?: React.Context<any> | undefined;
-    propTypes?: any;
-};
 export interface ObjectMap {
     nodes: {
         [name: string]: THREE.Object3D;
@@ -218,6 +37,12 @@ export interface ObjectMap {
     };
 }
 export declare function calculateDpr(dpr: Dpr): number;
+/**
+ * Calls `onChange` whenever window.devicePixelRatio changes: moving to another display or zooming.
+ * Neither resizes the canvas, so resize observers won't see it. A resolution query only matches the
+ * current ratio, so it is re-created after every change. Returns the unsubscribe function.
+ */
+export declare function watchDpr(onChange: () => void): () => void;
 /**
  * Returns instance root state
  */

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

@@ -34,7 +34,7 @@ export interface ReactProps<P> {
 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;
+    [K in keyof T & string as T[K] extends ConstructorRepresentation ? Uncapitalize<K> : never]: ThreeElement<T[K]>;
 };
 type ThreeExports = typeof THREE;
 type ThreeElementsImpl = ThreeToJSXElements<ThreeExports>;