@react-three/fiber 8.0.0-beta-04 → 8.0.0-beta.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @react-three/fiber
 
+## 8.0.0-beta.0
+
+### Patch Changes
+
+- cf6316c: new beta for library testing
+
+## 7.0.25
+
+### Patch Changes
+
+- 8698734: Release latest patches
+
+## 7.0.24
+
+### Patch Changes
+
+- 7f46ddf: cleanup captured pointers when released (#1914)
+
 ## 7.0.23
 
 ### Patch Changes

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

@@ -2,14 +2,14 @@
 import * as THREE from 'three';
 import * as React from 'react';
 import { UseStore } from 'zustand';
-import { dispose } from '../core/utils';
-import { Renderer, StoreProps, context, RootState, Size } from '../core/store';
-import { extend, Root } from '../core/renderer';
-import { addEffect, addAfterEffect, addTail } from '../core/loop';
+import { Renderer, StoreProps, context, RootState, Size } from './store';
+import { extend, Root } from './renderer';
+import { addEffect, addAfterEffect, addTail } from './loop';
 import { EventManager } from './events';
+import { dispose } from './utils';
 declare const roots: Map<Element, Root>;
-declare const invalidate: (state?: RootState | undefined) => void, advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState | undefined) => void;
-declare const reconciler: import("react-reconciler").Reconciler<unknown, unknown, unknown, unknown, unknown>, applyProps: typeof import("../core/utils").applyProps;
+declare const invalidate: (state?: RootState | undefined) => void, advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState | undefined, frame?: THREE.XRFrame | undefined) => void;
+declare const reconciler: import("react-reconciler").Reconciler<unknown, unknown, unknown, unknown, unknown>, applyProps: typeof import("./utils").applyProps;
 declare type Properties<T> = Pick<T, {
     [K in keyof T]: T[K] extends (_: any) => any ? never : K;
 }[keyof T]>;
@@ -20,12 +20,15 @@ export declare type RenderProps<TCanvas extends Element> = Omit<StoreProps, 'gl'
     size?: Size;
     onCreated?: (state: RootState) => void;
 };
-declare function createRoot<TCanvas extends Element>(canvas: TCanvas, config?: RenderProps<TCanvas>): {
+export declare type ReconcilerRoot<TCanvas extends Element> = {
+    configure: (config?: RenderProps<TCanvas>) => ReconcilerRoot<TCanvas>;
     render: (element: React.ReactNode) => UseStore<RootState>;
     unmount: () => void;
 };
+declare function createRoot<TCanvas extends Element>(canvas: TCanvas): ReconcilerRoot<TCanvas>;
 declare function render<TCanvas extends Element>(element: React.ReactNode, canvas: TCanvas, config?: RenderProps<TCanvas>): UseStore<RootState>;
 declare function unmountComponentAtNode<TElement extends Element>(canvas: TElement, callback?: (canvas: TElement) => void): void;
 declare const act: any;
 declare function createPortal(children: React.ReactNode, container: THREE.Object3D): React.ReactNode;
+export * from './hooks';
 export { context, render, createRoot, unmountComponentAtNode, createPortal, reconciler, applyProps, dispose, invalidate, advance, extend, addEffect, addAfterEffect, addTail, act, roots as _roots, };

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

@@ -1,3 +1,4 @@
+import * as THREE from 'three';
 import { Root } from './renderer';
 import { RootState } from './store';
 declare type GlobalRenderCallback = (timeStamp: number) => void;
@@ -5,8 +6,8 @@ export declare const addEffect: (callback: GlobalRenderCallback) => () => void;
 export declare const addAfterEffect: (callback: GlobalRenderCallback) => () => void;
 export declare const addTail: (callback: GlobalRenderCallback) => () => void;
 export declare function createLoop<TCanvas>(roots: Map<TCanvas, Root>): {
-    loop: (timestamp: number) => number | undefined;
+    loop: (timestamp: number) => void;
     invalidate: (state?: RootState | undefined) => void;
-    advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState | undefined) => void;
+    advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState | undefined, frame?: THREE.XRFrame | undefined) => void;
 };
 export {};

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

@@ -2,7 +2,6 @@ import * as THREE from 'three';
 import * as React from 'react';
 import * as ReactThreeFiber from '../three-types';
 import { GetState, SetState, UseStore } from 'zustand';
-import { Instance, InstanceProps } from './renderer';
 import { DomEvent, EventManager, PointerCaptureTarget, ThreeEvent } from './events';
 export interface Intersection extends THREE.Intersection {
     eventObject: THREE.Object3D;
@@ -29,7 +28,7 @@ export declare type Raycaster = THREE.Raycaster & {
     filter?: FilterFunction;
     computeOffsets?: ComputeOffsetsFunction;
 };
-export declare type RenderCallback = (state: RootState, delta: number) => void;
+export declare type RenderCallback = (state: RootState, delta: number, frame?: THREE.XRFrame) => void;
 export declare type Performance = {
     current: number;
     min: number;
@@ -40,13 +39,12 @@ export declare type Performance = {
 export declare type Renderer = {
     render: (scene: THREE.Scene, camera: THREE.Camera) => any;
 };
-export declare const isRenderer: (def: Renderer) => boolean;
-export declare const isOrthographicCamera: (def: THREE.Camera) => def is THREE.OrthographicCamera;
+export declare const isRenderer: (def: any) => boolean;
+export declare const isOrthographicCamera: (def: any) => def is THREE.OrthographicCamera;
 export declare type InternalState = {
     active: boolean;
     priority: number;
     frames: number;
-    lastProps: StoreProps;
     lastEvent: React.MutableRefObject<DomEvent | null>;
     interaction: THREE.Object3D[];
     hovered: Map<string, ThreeEvent<DomEvent>>;
@@ -54,20 +52,21 @@ export declare type InternalState = {
     capturedMap: Map<number, Map<THREE.Object3D, PointerCaptureTarget>>;
     initialClick: [x: number, y: number];
     initialHits: THREE.Object3D[];
-    xr: {
-        connect: () => void;
-        disconnect: () => void;
-    };
     subscribe: (callback: React.MutableRefObject<RenderCallback>, priority?: number) => () => void;
 };
 export declare type RootState = {
     gl: THREE.WebGLRenderer;
-    scene: THREE.Scene;
     camera: Camera & {
         manual?: boolean;
     };
-    controls: THREE.EventDispatcher | null;
     raycaster: Raycaster;
+    events: EventManager<any>;
+    xr: {
+        connect: () => void;
+        disconnect: () => void;
+    };
+    scene: THREE.Scene;
+    controls: THREE.EventDispatcher | null;
     mouse: THREE.Vector2;
     clock: THREE.Clock;
     linear: boolean;
@@ -86,13 +85,14 @@ export declare type RootState = {
     setDpr: (dpr: Dpr) => void;
     setFrameloop: (frameloop?: 'always' | 'demand' | 'never') => void;
     onPointerMissed?: (event: MouseEvent) => void;
-    events: EventManager<any>;
     internal: InternalState;
 };
 export declare type FilterFunction = (items: THREE.Intersection[], state: RootState) => THREE.Intersection[];
 export declare type ComputeOffsetsFunction = (event: any, state: RootState) => {
     offsetX: number;
     offsetY: number;
+    width?: number;
+    height?: number;
 };
 export declare type StoreProps = {
     gl: THREE.WebGLRenderer;
@@ -104,14 +104,12 @@ export declare type StoreProps = {
     frameloop?: 'always' | 'demand' | 'never';
     performance?: Partial<Omit<Performance, 'regress'>>;
     dpr?: Dpr;
-    clock?: THREE.Clock;
     raycaster?: Partial<Raycaster>;
     camera?: (Camera | Partial<ReactThreeFiber.Object3DNode<THREE.Camera, typeof THREE.Camera> & ReactThreeFiber.Object3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera> & ReactThreeFiber.Object3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>>) & {
         manual?: boolean;
     };
     onPointerMissed?: (event: MouseEvent) => void;
 };
-export declare type ApplyProps = (instance: Instance, newProps: InstanceProps) => void;
 declare const context: React.Context<UseStore<RootState>>;
-declare const createStore: (applyProps: ApplyProps, invalidate: (state?: RootState | undefined) => void, advance: (timestamp: number, runGlobalEffects?: boolean | undefined, state?: RootState | undefined) => void, props: StoreProps) => UseStore<RootState>;
+declare const createStore: (invalidate: (state?: RootState | undefined) => void, advance: (timestamp: number, runGlobalEffects?: boolean | undefined, state?: RootState | undefined, frame?: THREE.XRFrame | undefined) => void) => UseStore<RootState>;
 export { createStore, context };

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

@@ -26,14 +26,20 @@ export declare function filterKeys<TObj extends {
 }, TOmit extends boolean, TKey extends keyof TObj>(obj: TObj, omit: TOmit, ...keys: TKey[]): TOmit extends true ? Omit<TObj, TKey> : Pick<TObj, TKey>;
 export declare const pick: <TObj>(obj: Partial<TObj>, keys: (keyof TObj)[]) => Pick<Partial<TObj>, keyof TObj>;
 export declare const omit: <TObj>(obj: Partial<TObj>, keys: (keyof TObj)[]) => Omit<Partial<TObj>, keyof TObj>;
+export declare type EquConfig = {
+    arrays?: 'reference' | 'shallow';
+    objects?: 'reference' | 'shallow';
+    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): boolean;
+    equ(a: any, b: any, { arrays, objects, strict }?: EquConfig): boolean;
 };
 export declare function buildGraph(object: THREE.Object3D): ObjectMap;
 export declare function dispose<TObj extends {

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

@@ -1,10 +1,10 @@
 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, Camera, RenderCallback, Performance, RootState, } from './core/store';
 export type { ThreeEvent, Events, EventManager } from './core/events';
 export type { ObjectMap } from './core/utils';
-export * from './core/hooks';
 export * from './web/Canvas';
 export { createPointerEvents as events } from './web/events';
 export * from './core';

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

@@ -1,10 +1,10 @@
 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, Camera, RenderCallback, Performance, RootState, } from './core/store';
 export type { ThreeEvent, Events, EventManager } from './core/events';
 export type { ObjectMap } from './core/utils';
-export * from './native/hooks';
 export * from './native/Canvas';
 export { createTouchEvents as events } from './native/events';
 export * from './core';

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

@@ -24,7 +24,10 @@ export interface NodeProps<T, P> {
     key?: React.Key;
     onUpdate?: (self: T) => void;
 }
-export declare type Node<T, P> = Overwrite<Partial<T>, NodeProps<T, P>>;
+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;
@@ -35,13 +38,9 @@ export declare type Object3DNode<T, P> = Overwrite<Node<T, P>, {
     layers?: Layers;
     dispose?: (() => void) | null;
 }> & EventHandlers;
-export declare type BufferGeometryNode<T extends THREE.BufferGeometry, P> = Overwrite<Node<T, P>, {}>;
-export declare type MaterialNode<T extends THREE.Material, P> = Overwrite<Node<T, P>, {
-    color?: Color;
-}>;
-export declare type LightNode<T extends THREE.Light, P> = Overwrite<Object3DNode<T, P>, {
-    color?: Color;
-}>;
+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 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>;