@react-three/fiber 9.0.0-rc.0 → 9.0.0-rc.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @react-three/fiber
 
+## 8.17.12
+
+### Patch Changes
+
+- ff1a16f1: fix: narrow React peer dep range
+
+## 8.17.11
+
+### Patch Changes
+
+- 7461bf0c: fix: loosen instanceof checks for CSB issue
+
 ## 8.17.10
 
 ### Patch Changes

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

@@ -2,10 +2,10 @@ 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 } from "./reconciler.js";
+import type { Instance, ConstructorRepresentation } from "./reconciler.js";
 /**
  * Exposes an object's {@link Instance}.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#useinstancehandle
+ * @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.
  */
@@ -31,22 +31,20 @@ export declare function useFrame(callback: RenderCallback, renderPriority?: numb
  * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usegraph
  */
 export declare function useGraph(object: THREE.Object3D): ObjectMap;
-export interface Loader<T> extends THREE.Loader {
-    load(url: string | string[] | string[][], onLoad?: (result: T, ...args: any[]) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: unknown) => void): unknown;
-}
-export type LoaderProto<T> = new (...args: any[]) => Loader<T>;
-export type LoaderResult<T> = T extends {
+type LoaderInstance<T extends THREE.Loader<any> | ConstructorRepresentation<THREE.Loader<any>>> = T extends ConstructorRepresentation<THREE.Loader<any>> ? InstanceType<T> : T;
+export type LoaderResult<T extends THREE.Loader<any> | ConstructorRepresentation<THREE.Loader<any>>> = Awaited<ReturnType<LoaderInstance<T>['loadAsync']>> extends infer R ? R extends {
     scene: THREE.Object3D;
-} ? T & ObjectMap : T;
-export type Extensions<T> = (loader: Loader<T>) => void;
+} ? R & ObjectMap : R : never;
+export type Extensions<T extends THREE.Loader<any> | ConstructorRepresentation<THREE.Loader<any>>> = (loader: LoaderInstance<T>) => void;
 /**
  * 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[] | string[][]>(loader: Loader<T> | LoaderProto<T>, input: U, extensions?: Extensions<T>, onProgress?: (event: ProgressEvent) => void): U extends any[] ? LoaderResult<T>[] : LoaderResult<T>;
+export declare function useLoader<T, U extends string | string[] | string[][], L extends THREE.Loader<any> | ConstructorRepresentation<THREE.Loader<any>>>(loader: L, input: U, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void): U extends any[] ? LoaderResult<L>[] : LoaderResult<L>;
 export declare namespace useLoader {
-    var preload: <T, U extends string | string[] | string[][]>(loader: Loader<T> | LoaderProto<T>, input: U, extensions?: Extensions<T> | undefined) => void;
-    var clear: <T, U extends string | string[] | string[][]>(loader: Loader<T> | LoaderProto<T>, input: U) => void;
+    var preload: <T, U extends string | string[] | string[][], L extends THREE.Loader<any, string> | ConstructorRepresentation<THREE.Loader<any, string>>>(loader: L, input: U, extensions?: Extensions<L> | undefined) => void;
+    var clear: <T, U extends string | string[] | string[][], L extends THREE.Loader<any, string> | ConstructorRepresentation<THREE.Loader<any, string>>>(loader: L, input: U) => void;
 }
+export {};

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

@@ -5,9 +5,6 @@ import { IsAllOptional } from "./utils.js";
 import type { RootStore } from "./store.js";
 import { type EventHandlers } from "./events.js";
 import type { ThreeElement } from "../three-types.js";
-declare module 'react-reconciler/constants' {
-    const NoEventPriority = 0;
-}
 export interface Root {
     fiber: Reconciler.FiberRoot;
     store: RootStore;

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

@@ -2,7 +2,7 @@ import * as THREE from 'three';
 import * as React from 'react';
 import { Instance } from "./reconciler.js";
 import type { Fiber } from 'react-reconciler';
-import type { Dpr, Renderer, RootStore, Size } from "./store.js";
+import type { Dpr, RootStore, Size } from "./store.js";
 export type NonFunctionKeys<P> = {
     [K in keyof P]-?: P[K] extends Function ? never : K;
 }[keyof P];
@@ -17,23 +17,6 @@ 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;
-/**
- * Returns `true` with correct TS type inference if an object has a configurable color space (since r152).
- */
-export declare const hasColorSpace: <T extends object | THREE.Texture | Renderer, P = T extends Renderer ? {
-    outputColorSpace: string;
-} : {
-    colorSpace: string;
-}>(object: T) => object is T & P;
-export type ColorManagementRepresentation = {
-    enabled: boolean | never;
-} | {
-    legacyMode: boolean | never;
-};
-/**
- * The current THREE.ColorManagement instance, if present.
- */
-export declare const getColorManagement: () => ColorManagementRepresentation | null;
 export type Act = <T = any>(cb: () => Promise<T>) => Promise<T>;
 /**
  * Safely flush async effects when testing, simulating a legacy root.
@@ -68,21 +51,85 @@ export type UnblockProps = {
     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;
+export declare const ErrorBoundary: {
+    new (props: {
+        set: React.Dispatch<Error | undefined>;
+        children: React.ReactNode;
+    }): {
+        state: {
+            error: boolean;
+        };
+        componentDidCatch(err: Error): void;
+        render(): React.ReactNode;
+        context: unknown;
+        setState<K extends "error">(state: {
+            error: boolean;
+        } | ((prevState: Readonly<{
+            error: boolean;
+        }>, props: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>) => {
+            error: boolean;
+        } | Pick<{
+            error: boolean;
+        }, K> | null) | Pick<{
+            error: boolean;
+        }, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>): boolean;
+        componentWillUnmount?(): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, prevState: Readonly<{
+            error: boolean;
+        }>): any;
+        componentDidUpdate?(prevProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, prevState: Readonly<{
+            error: boolean;
+        }>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>): void;
+        componentWillUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>): void;
     };
-    static getDerivedStateFromError: () => {
+    getDerivedStateFromError: () => {
         error: boolean;
     };
-    componentDidCatch(err: Error): void;
-    render(): React.ReactNode;
-}
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};
 export interface ObjectMap {
     nodes: {
         [name: string]: THREE.Object3D;
@@ -135,4 +182,4 @@ export declare function diffProps<T = any>(instance: Instance<T>, newProps: Inst
 export declare function applyProps<T = any>(object: Instance<T>['object'], props: Instance<T>['props']): Instance<T>['object'];
 export declare function invalidateInstance(instance: Instance): void;
 export declare function updateCamera(camera: Camera, size: Size): void;
-export declare const isObject3D: (object: any) => object is THREE.Object3D<THREE.Event>;
+export declare const isObject3D: (object: any) => object is THREE.Object3D<THREE.Object3DEventMap>;