@react-three/fiber 8.0.0-beta-05 → 8.0.0-beta.10

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @react-three/fiber
 
+## 8.0.0-beta.0
+
+### Patch Changes
+
+- cf6316c: new beta for library testing
+
 ## 7.0.25
 
 ### Patch Changes

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

@@ -1,21 +1,20 @@
 import * as THREE from 'three';
-import type { UseStore } from 'zustand';
+import type { UseBoundStore } from 'zustand';
 import type { RootState } from './store';
 export interface Intersection extends THREE.Intersection {
     eventObject: THREE.Object3D;
 }
 export interface IntersectionEvent<TSourceEvent> extends Intersection {
+    eventObject: THREE.Object3D;
     intersections: Intersection[];
-    stopped: boolean;
     unprojectedPoint: THREE.Vector3;
+    pointer: THREE.Vector2;
+    delta: number;
     ray: THREE.Ray;
     camera: Camera;
     stopPropagation: () => void;
-    sourceEvent: TSourceEvent;
     nativeEvent: TSourceEvent;
-    delta: number;
-    spaceX: number;
-    spaceY: number;
+    stopped: boolean;
 }
 export declare type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
 export declare type ThreeEvent<TEvent> = IntersectionEvent<TEvent>;
@@ -47,8 +46,14 @@ export declare type EventHandlers = {
     onPointerCancel?: (event: ThreeEvent<PointerEvent>) => void;
     onWheel?: (event: ThreeEvent<WheelEvent>) => void;
 };
+export declare type FilterFunction = (items: THREE.Intersection[], state: RootState) => THREE.Intersection[];
+export declare type ComputeFunction = (event: DomEvent, root: RootState, previous?: RootState) => void;
 export interface EventManager<TTarget> {
-    connected: TTarget | boolean;
+    enabled: boolean;
+    priority: number;
+    compute?: ComputeFunction;
+    filter?: FilterFunction;
+    connected?: TTarget;
     handlers?: Events;
     connect?: (target: TTarget) => void;
     disconnect?: () => void;
@@ -58,7 +63,7 @@ export interface PointerCaptureTarget {
     target: Element;
 }
 export declare function getEventPriority(): any;
-export declare function removeInteractivity(store: UseStore<RootState>, object: THREE.Object3D): void;
-export declare function createEvents(store: UseStore<RootState>): {
+export declare function removeInteractivity(store: UseBoundStore<RootState>, object: THREE.Object3D): void;
+export declare function createEvents(store: UseBoundStore<RootState>): {
     handlePointer: (name: string) => (event: DomEvent) => void;
 };

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

@@ -10,12 +10,16 @@ export declare type Extensions = (loader: THREE.Loader) => void;
 export declare type LoaderResult<T> = T extends any[] ? Loader<T[number]> : Loader<T>;
 export declare type ConditionalType<Child, Parent, Truthy, Falsy> = Child extends Parent ? Truthy : Falsy;
 export declare type BranchingReturn<T, Parent, Coerced> = ConditionalType<T, Parent, Coerced, T>;
-export declare function useStore(): import("zustand").UseStore<RootState>;
+declare type noop = (...args: any[]) => any;
+declare type PickFunction<T extends noop> = (...args: Parameters<T>) => ReturnType<T>;
+export declare function useStore(): import("zustand").UseBoundStore<RootState, import("zustand").StoreApi<RootState>>;
 export declare function useThree<T = RootState>(selector?: StateSelector<RootState, T>, equalityFn?: EqualityChecker<T>): T;
 export declare function useFrame(callback: RenderCallback, renderPriority?: number): null;
 export declare function useGraph(object: THREE.Object3D): ObjectMap;
+export declare function useMemoizedFn<T extends noop>(fn?: T): PickFunction<T>;
 export declare function useLoader<T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U, extensions?: Extensions, onProgress?: (event: ProgressEvent<EventTarget>) => void): U extends any[] ? BranchingReturn<T, GLTF, GLTF & ObjectMap>[] : BranchingReturn<T, GLTF, GLTF & ObjectMap>;
 export declare namespace useLoader {
     var preload: <T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U, extensions?: Extensions | undefined) => undefined;
     var clear: <T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U) => void;
 }
+export {};

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

@@ -1,32 +1,42 @@
 /// <reference types="react-reconciler" />
 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 { EventManager } from './events';
+import { UseBoundStore } from 'zustand';
+import { Renderer, StoreProps, context, RootState, Size } from './store';
+import { extend, Root } from './renderer';
+import { addEffect, addAfterEffect, addTail } from './loop';
+import { EventManager, ComputeFunction } from './events';
+import { dispose, getRootState } from './utils';
 declare const roots: Map<Element, Root>;
 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("../core/utils").applyProps;
+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]>;
 declare type GLProps = Renderer | ((canvas: HTMLCanvasElement) => Renderer) | Partial<Properties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters> | undefined;
 export declare type RenderProps<TCanvas extends Element> = Omit<StoreProps, 'gl' | 'events' | 'size'> & {
     gl?: GLProps;
-    events?: (store: UseStore<RootState>) => EventManager<TCanvas>;
+    events?: (store: UseBoundStore<RootState>) => EventManager<TCanvas>;
     size?: Size;
     onCreated?: (state: RootState) => void;
 };
-declare function createRoot<TCanvas extends Element>(canvas: TCanvas, config?: RenderProps<TCanvas>): {
-    render: (element: React.ReactNode) => UseStore<RootState>;
+export declare type ReconcilerRoot<TCanvas extends Element> = {
+    configure: (config?: RenderProps<TCanvas>) => ReconcilerRoot<TCanvas>;
+    render: (element: React.ReactNode) => UseBoundStore<RootState>;
     unmount: () => void;
 };
-declare function render<TCanvas extends Element>(element: React.ReactNode, canvas: TCanvas, config?: RenderProps<TCanvas>): UseStore<RootState>;
+declare function createRoot<TCanvas extends Element>(canvas: TCanvas): ReconcilerRoot<TCanvas>;
+declare function render<TCanvas extends Element>(children: React.ReactNode, canvas: TCanvas, config: RenderProps<TCanvas>): UseBoundStore<RootState>;
 declare function unmountComponentAtNode<TElement extends Element>(canvas: TElement, callback?: (canvas: TElement) => void): void;
+export declare type InjectState = Partial<Omit<RootState, 'set' | 'get' | 'setSize' | 'setFrameloop' | 'setDpr' | 'events' | 'invalidate' | 'advance' | 'performance' | 'internal'> & {
+    events: {
+        enabled?: boolean;
+        priority?: number;
+        compute?: ComputeFunction;
+        connected?: any;
+    };
+}>;
+declare function createPortal(children: React.ReactNode, container: THREE.Object3D, state?: InjectState): React.ReactNode;
 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, };
+export { context, render, createRoot, unmountComponentAtNode, createPortal, reconciler, applyProps, dispose, invalidate, advance, extend, addEffect, addAfterEffect, addTail, getRootState, act, roots as _roots, };

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

@@ -6,7 +6,7 @@ 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, frame?: THREE.XRFrame | undefined) => void;
 };

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

@@ -1,28 +1,29 @@
 import * as THREE from 'three';
-import { UseStore } from 'zustand';
+import { UseBoundStore } from 'zustand';
 import Reconciler from 'react-reconciler';
 import { prepare, applyProps } from './utils';
 import { RootState } from './store';
 import { EventHandlers } from './events';
 export declare type Root = {
     fiber: Reconciler.FiberRoot;
-    store: UseStore<RootState>;
+    store: UseBoundStore<RootState>;
 };
 export declare type LocalState = {
-    root: UseStore<RootState>;
+    type: string;
+    root: UseBoundStore<RootState>;
     objects: Instance[];
     parent: Instance | null;
     primitive?: boolean;
     eventCount: number;
     handlers: Partial<EventHandlers>;
     attach?: AttachType;
-    previousAttach?: any;
+    previousAttach: any;
     memoizedProps: {
         [key: string]: any;
     };
 };
-export declare type AttachFnType = (parent: Instance, self: Instance) => void;
-export declare type AttachType = string | [attach: string | AttachFnType, detach: string | AttachFnType];
+export declare type AttachFnType = (parent: Instance, self: Instance) => () => void;
+export declare type AttachType = string | AttachFnType;
 export declare type BaseInstance = Omit<THREE.Object3D, 'children' | 'attach' | 'add' | 'remove' | 'raycast'> & {
     __r3f: LocalState;
     children: Instance[];

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

@@ -1,8 +1,7 @@
 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 { GetState, SetState, StoreApi, UseBoundStore } from 'zustand';
 import { DomEvent, EventManager, PointerCaptureTarget, ThreeEvent } from './events';
 export interface Intersection extends THREE.Intersection {
     eventObject: THREE.Object3D;
@@ -24,11 +23,6 @@ export declare type Viewport = Size & {
     aspect: number;
 };
 export declare type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
-export declare type Raycaster = THREE.Raycaster & {
-    enabled: boolean;
-    filter?: FilterFunction;
-    computeOffsets?: ComputeOffsetsFunction;
-};
 export declare type RenderCallback = (state: RootState, delta: number, frame?: THREE.XRFrame) => void;
 export declare type Performance = {
     current: number;
@@ -40,13 +34,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,48 +47,44 @@ 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 = {
+    set: SetState<RootState>;
+    get: GetState<RootState>;
     gl: THREE.WebGLRenderer;
-    scene: THREE.Scene;
     camera: Camera & {
         manual?: boolean;
     };
+    scene: THREE.Scene;
+    raycaster: THREE.Raycaster;
+    clock: THREE.Clock;
+    events: EventManager<any>;
+    xr: {
+        connect: () => void;
+        disconnect: () => void;
+    };
     controls: THREE.EventDispatcher | null;
-    raycaster: Raycaster;
+    pointer: THREE.Vector2;
     mouse: THREE.Vector2;
-    clock: THREE.Clock;
     linear: boolean;
     flat: boolean;
     frameloop: 'always' | 'demand' | 'never';
     performance: Performance;
     size: Size;
     viewport: Viewport & {
-        getCurrentViewport: (camera?: Camera, target?: THREE.Vector3, size?: Size) => Omit<Viewport, 'dpr' | 'initialDpr'>;
+        getCurrentViewport: (camera?: Camera, target?: THREE.Vector3 | Parameters<THREE.Vector3['set']>, size?: Size) => Omit<Viewport, 'dpr' | 'initialDpr'>;
     };
-    set: SetState<RootState>;
-    get: GetState<RootState>;
     invalidate: () => void;
     advance: (timestamp: number, runGlobalEffects?: boolean) => void;
+    setEvents: (events: Partial<EventManager<any>>) => void;
     setSize: (width: number, height: number) => void;
     setDpr: (dpr: Dpr) => void;
     setFrameloop: (frameloop?: 'always' | 'demand' | 'never') => void;
     onPointerMissed?: (event: MouseEvent) => void;
-    events: EventManager<any>;
+    previousRoot?: UseBoundStore<RootState, StoreApi<RootState>>;
     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;
     size: Size;
@@ -106,14 +95,12 @@ export declare type StoreProps = {
     frameloop?: 'always' | 'demand' | 'never';
     performance?: Partial<Omit<Performance, 'regress'>>;
     dpr?: Dpr;
-    clock?: THREE.Clock;
-    raycaster?: Partial<Raycaster>;
+    raycaster?: Partial<THREE.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, frame?: THREE.XRFrame | undefined) => void, props: StoreProps) => UseStore<RootState>;
+declare const context: React.Context<UseBoundStore<RootState, StoreApi<RootState>>>;
+declare const createStore: (invalidate: (state?: RootState | undefined) => void, advance: (timestamp: number, runGlobalEffects?: boolean | undefined, state?: RootState | undefined, frame?: THREE.XRFrame | undefined) => void) => UseBoundStore<RootState>;
 export { createStore, context };

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

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import { AttachType, Instance, InstanceProps, LocalState } from './renderer';
-import { Dpr } from './store';
+import { Dpr, RootState } from './store';
 export declare const DEFAULT = "__default";
 export declare type DiffSet = {
     memoized: {
@@ -21,19 +21,26 @@ export declare type ObjectMap = {
     };
 };
 export declare function calculateDpr(dpr: Dpr): number;
+export declare const getRootState: (obj: THREE.Object3D) => RootState | undefined;
 export declare function filterKeys<TObj extends {
     [key: string]: any;
 }, 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 {
@@ -45,6 +52,6 @@ export declare function prepare<T = THREE.Object3D>(object: T, state?: Partial<L
 export declare function attach(parent: Instance, child: Instance, type: AttachType): void;
 export declare function detach(parent: Instance, child: Instance, type: AttachType): void;
 export declare function diffProps(instance: Instance, { children: cN, key: kN, ref: rN, ...props }: InstanceProps, { children: cP, key: kP, ref: rP, ...previous }?: InstanceProps, remove?: boolean): DiffSet;
-export declare function applyProps(instance: Instance, data: InstanceProps | DiffSet): void;
+export declare function applyProps(instance: Instance, data: InstanceProps | DiffSet): Instance;
 export declare function invalidateInstance(instance: Instance): void;
 export declare function updateInstance(instance: Instance): void;

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

@@ -1,6 +1,7 @@
 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';

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

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { View, ViewProps, ViewStyle } from 'react-native';
-import { UseStore } from 'zustand';
+import { UseBoundStore } from 'zustand';
 import { RenderProps } from '../core';
 import { RootState } from '../core/store';
 import { EventManager } from '../core/events';
@@ -8,6 +8,6 @@ export interface Props extends Omit<RenderProps<HTMLCanvasElement>, 'size' | 'ev
     children: React.ReactNode;
     fallback?: React.ReactNode;
     style?: ViewStyle;
-    events?: (store: UseStore<RootState>) => EventManager<any>;
+    events?: (store: UseBoundStore<RootState>) => EventManager<any>;
 }
 export declare const Canvas: React.ForwardRefExoticComponent<Props & React.RefAttributes<View>>;

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

@@ -1,5 +1,5 @@
-import { UseStore } from 'zustand';
+import { UseBoundStore } from 'zustand';
 import { RootState } from '../core/store';
 import { EventManager } from '../core/events';
 import { View } from 'react-native';
-export declare function createTouchEvents(store: UseStore<RootState>): EventManager<View>;
+export declare function createTouchEvents(store: UseBoundStore<RootState>): EventManager<View>;

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

@@ -1,6 +1,7 @@
 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';

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

@@ -41,6 +41,7 @@ export declare type Object3DNode<T, P> = Overwrite<Node<T, P>, {
 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 Object3DProps = Object3DNode<THREE.Object3D, typeof THREE.Object3D>;
 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>;
@@ -166,7 +167,15 @@ export declare type Matrix3Props = Node<THREE.Matrix3, typeof THREE.Matrix3>;
 export declare type Matrix4Props = Node<THREE.Matrix4, typeof THREE.Matrix4>;
 export declare type QuaternionProps = Node<THREE.Quaternion, typeof THREE.Quaternion>;
 export declare type BufferAttributeProps = Node<THREE.BufferAttribute, typeof THREE.BufferAttribute>;
+export declare type Float16BufferAttributeProps = Node<THREE.Float16BufferAttribute, typeof THREE.Float16BufferAttribute>;
 export declare type Float32BufferAttributeProps = Node<THREE.Float32BufferAttribute, typeof THREE.Float32BufferAttribute>;
+export declare type Float64BufferAttributeProps = Node<THREE.Float64BufferAttribute, typeof THREE.Float64BufferAttribute>;
+export declare type Int8BufferAttributeProps = Node<THREE.Int8BufferAttribute, typeof THREE.Int8BufferAttribute>;
+export declare type Int16BufferAttributeProps = Node<THREE.Int16BufferAttribute, typeof THREE.Int16BufferAttribute>;
+export declare type Int32BufferAttributeProps = Node<THREE.Int32BufferAttribute, typeof THREE.Int32BufferAttribute>;
+export declare type Uint8BufferAttributeProps = Node<THREE.Uint8BufferAttribute, typeof THREE.Uint8BufferAttribute>;
+export declare type Uint16BufferAttributeProps = Node<THREE.Uint16BufferAttribute, typeof THREE.Uint16BufferAttribute>;
+export declare type Uint32BufferAttributeProps = Node<THREE.Uint32BufferAttribute, typeof THREE.Uint32BufferAttribute>;
 export declare type InstancedBufferAttributeProps = Node<THREE.InstancedBufferAttribute, typeof THREE.InstancedBufferAttribute>;
 export declare type ColorProps = Node<THREE.Color, ColorArray>;
 export declare type FogProps = Node<THREE.Fog, typeof THREE.Fog>;
@@ -175,6 +184,7 @@ export declare type ShapeProps = Node<THREE.Shape, typeof THREE.Shape>;
 declare global {
     namespace JSX {
         interface IntrinsicElements {
+            object3D: Object3DProps;
             audioListener: AudioListenerProps;
             positionalAudio: PositionalAudioProps;
             mesh: MeshProps;
@@ -296,7 +306,15 @@ declare global {
             matrix4: Matrix4Props;
             quaternion: QuaternionProps;
             bufferAttribute: BufferAttributeProps;
+            float16BufferAttribute: Float16BufferAttributeProps;
             float32BufferAttribute: Float32BufferAttributeProps;
+            float64BufferAttribute: Float64BufferAttributeProps;
+            int8BufferAttribute: Int8BufferAttributeProps;
+            int16BufferAttribute: Int16BufferAttributeProps;
+            int32BufferAttribute: Int32BufferAttributeProps;
+            uint8BufferAttribute: Uint8BufferAttributeProps;
+            uint16BufferAttribute: Uint16BufferAttributeProps;
+            uint32BufferAttribute: Uint32BufferAttributeProps;
             instancedBufferAttribute: InstancedBufferAttributeProps;
             color: ColorProps;
             fog: FogProps;

package/dist/declarations/src/web/Canvas.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import type { Options as ResizeOptions } from 'react-use-measure';
-import { UseStore } from 'zustand';
+import { UseBoundStore } from 'zustand';
 import { RenderProps } from '../core';
 import { RootState } from '../core/store';
 import { EventManager } from '../core/events';
@@ -8,6 +8,6 @@ export interface Props extends Omit<RenderProps<HTMLCanvasElement>, 'size' | 'ev
     children: React.ReactNode;
     fallback?: React.ReactNode;
     resize?: ResizeOptions;
-    events?: (store: UseStore<RootState>) => EventManager<any>;
+    events?: (store: UseBoundStore<RootState>) => EventManager<any>;
 }
 export declare const Canvas: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLCanvasElement>>;

package/dist/declarations/src/web/events.d.ts

@@ -1,4 +1,4 @@
-import { UseStore } from 'zustand';
+import { UseBoundStore } from 'zustand';
 import { RootState } from '../core/store';
 import { EventManager } from '../core/events';
-export declare function createPointerEvents(store: UseStore<RootState>): EventManager<HTMLElement>;
+export declare function createPointerEvents(store: UseBoundStore<RootState>): EventManager<HTMLElement>;