@react-three/fiber 8.0.0-beta.2 → 8.0.0-beta.5

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

@@ -1,5 +1,5 @@
 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;
@@ -58,7 +58,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

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
-import { StateSelector, EqualityChecker } from 'zustand';
+import * as React from 'react';
+import { StateSelector, EqualityChecker, UseBoundStore } from 'zustand';
 import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
 import { RootState, RenderCallback } from './store';
 import { ObjectMap } from './utils';
@@ -10,8 +11,11 @@ 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, import("zustand").StoreApi<RootState>>;
+export declare function useStore(): UseBoundStore<RootState, import("zustand").StoreApi<RootState>>;
 export declare function useThree<T = RootState>(selector?: StateSelector<RootState, T>, equalityFn?: EqualityChecker<T>): T;
+export declare function useInject(state: Partial<RootState>): [React.FC<{
+    children: React.ReactNode;
+}>, UseBoundStore<RootState, import("zustand").StoreApi<RootState>>];
 export declare function useFrame(callback: RenderCallback, renderPriority?: number): null;
 export declare function useGraph(object: THREE.Object3D): ObjectMap;
 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>;

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

@@ -1,7 +1,7 @@
 /// <reference types="react-reconciler" />
 import * as THREE from 'three';
 import * as React from 'react';
-import { UseStore } from 'zustand';
+import { UseBoundStore } from 'zustand';
 import { Renderer, StoreProps, context, RootState, Size } from './store';
 import { extend, Root } from './renderer';
 import { addEffect, addAfterEffect, addTail } from './loop';
@@ -16,19 +16,19 @@ declare type Properties<T> = Pick<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;
 };
 export declare type ReconcilerRoot<TCanvas extends Element> = {
     configure: (config?: RenderProps<TCanvas>) => ReconcilerRoot<TCanvas>;
-    render: (element: React.ReactNode) => UseStore<RootState>;
+    render: (element: React.ReactNode) => UseBoundStore<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 render<TCanvas extends Element>(element: React.ReactNode, canvas: TCanvas, config?: RenderProps<TCanvas>): UseBoundStore<RootState>;
 declare function unmountComponentAtNode<TElement extends Element>(canvas: TElement, callback?: (canvas: TElement) => void): void;
+declare function createPortal(children: React.ReactNode, container: THREE.Object3D, state?: Partial<RootState>): 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, };

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,7 +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 { GetState, SetState, UseBoundStore } from 'zustand';
 import { DomEvent, EventManager, PointerCaptureTarget, ThreeEvent } from './events';
 export interface Intersection extends THREE.Intersection {
     eventObject: THREE.Object3D;
@@ -110,6 +110,6 @@ export declare type StoreProps = {
     };
     onPointerMissed?: (event: MouseEvent) => void;
 };
-declare const context: React.Context<UseStore<RootState, import("zustand").StoreApi<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>;
+declare const context: React.Context<UseBoundStore<RootState, import("zustand").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/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/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>;