@react-three/fiber 9.8.0 → 9.8.2

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 renderer Context and StrictMode from a primary renderer.
- */
-export declare function useBridge(): Bridge;
-export type SetBlock = false | Promise<null> | null;
-export type UnblockProps = {
-    set: React.Dispatch<React.SetStateAction<SetBlock>>;
-    children: React.ReactNode;
-};
-export declare function Block({ set }: Omit<UnblockProps, 'children'>): null;
-export declare const ErrorBoundary: {
-    new (props: {
-        set: React.Dispatch<Error | undefined>;
-        children: React.ReactNode;
-    }): {
-        state: {
-            error: boolean;
-        };
-        componentDidCatch(err: Error): void;
-        render(): React.ReactNode;
-        context: unknown;
-        setState<K extends "error">(state: {
-            error: boolean;
-        } | ((prevState: Readonly<{
-            error: boolean;
-        }>, props: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>) => {
-            error: boolean;
-        } | Pick<{
-            error: boolean;
-        }, K> | null) | Pick<{
-            error: boolean;
-        }, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>;
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<{
-            set: React.Dispatch<Error | undefined>;
-            children: React.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>, 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>;