@react-three/fiber 8.0.0-alpha-05 → 8.0.0-alpha-09

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @react-three/fiber
 
+## 7.0.7
+
+### Patch Changes
+
+- 0375896: Simplify useframe, support instanced event cancelation, silence disposal
+
 ## 7.0.6
 
 ### Patch Changes

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

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
-import type { UseStore } from 'zustand';
-import type { RootState } from './store';
+import { UseStore } from 'zustand';
+import { RootState } from './store';
 export interface Intersection extends THREE.Intersection {
     eventObject: THREE.Object3D;
 }

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

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import { StateSelector, EqualityChecker } from 'zustand';
-import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
 import { RootState, RenderCallback } from './store';
 export interface Loader<T> extends THREE.Loader {
     load(url: string, onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): unknown;

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

@@ -1,6 +1,7 @@
 import * as THREE from 'three';
-import Reconciler from 'react-reconciler';
 import { UseStore } from 'zustand';
+import Reconciler from 'react-reconciler';
+import { prepare, applyProps } from './utils';
 import { RootState } from './store';
 import { EventHandlers } from './events';
 export declare type Root = {
@@ -10,15 +11,14 @@ export declare type Root = {
 export declare type LocalState = {
     root: UseStore<RootState>;
     objects: Instance[];
-    instance?: boolean;
-    handlers?: EventHandlers;
+    primitive?: boolean;
+    handlers: {
+        count: number;
+    } & Partial<EventHandlers>;
     memoizedProps: {
         [key: string]: any;
     };
 };
-export declare type ClassConstructor = {
-    new (): void;
-};
 export declare type AttachFnType = (self: Instance, parent: Instance) => void;
 export declare type AttachFnsType = [attach: string | AttachFnType, detach: string | AttachFnType];
 export declare type BaseInstance = Omit<THREE.Object3D, 'parent' | 'children' | 'attach' | 'add' | 'remove' | 'raycast'> & {
@@ -44,9 +44,8 @@ export declare type InstanceProps = {
     attach?: string;
 };
 declare let extend: (objects: object) => void;
-declare function prepare<T = THREE.Object3D>(object: T, state?: Partial<LocalState>): T;
-declare function createRenderer<TCanvas>(roots: Map<TCanvas, Root>): {
+declare function createRenderer<TCanvas>(roots: Map<TCanvas, Root>, getEventPriority?: () => any): {
     reconciler: Reconciler.Reconciler<unknown, unknown, unknown, unknown, unknown>;
-    applyProps: (instance: Instance, newProps: InstanceProps, oldProps?: InstanceProps, accumulative?: boolean) => void;
+    applyProps: typeof applyProps;
 };
 export { prepare, createRenderer, extend };

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

@@ -100,7 +100,7 @@ export declare type StoreProps = {
     camera?: Camera | Partial<ReactThreeFiber.Object3DNode<THREE.Camera, typeof THREE.Camera> & ReactThreeFiber.Object3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera> & ReactThreeFiber.Object3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>>;
     onPointerMissed?: (event: ThreeEvent<PointerEvent>) => void;
 };
-export declare type ApplyProps = (instance: Instance, newProps: InstanceProps, oldProps?: InstanceProps, accumulative?: boolean) => 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>;
 export { createStore, context };

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

@@ -0,0 +1,27 @@
+import * as THREE from 'three';
+import { Instance, InstanceProps, LocalState } from './renderer';
+export declare const DEFAULT = "__default";
+export declare type DiffSet = {
+    memoized: {
+        [key: string]: any;
+    };
+    changes: [key: string, value: unknown, isEvent: boolean, instance: Instance, prop: any][];
+};
+export declare const isDiffSet: (def: any) => def is DiffSet;
+export declare type ClassConstructor = {
+    new (): void;
+};
+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;
+    und: (a: any) => boolean;
+    arr: (a: any) => boolean;
+    equ(a: any, b: any): boolean;
+};
+export declare function prepare<T = THREE.Object3D>(object: T, state?: Partial<LocalState>): T;
+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 invalidateInstance(instance: Instance): void;
+export declare function updateInstance(instance: Instance): void;

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

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { Options as ResizeOptions } from 'react-use-measure';
-import { RenderProps } from './index';
 import { UseStore } from 'zustand';
+import { RenderProps } from './index';
 import { RootState } from '../core/store';
 import { EventManager } from '../core/events';
 export interface Props extends Omit<RenderProps<HTMLCanvasElement>, 'size' | 'events'>, React.HTMLAttributes<HTMLDivElement> {

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

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

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

@@ -10,9 +10,9 @@ import { Canvas } from './Canvas';
 import { EventManager } from '../core/events';
 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: (instance: import("../core/renderer").Instance, newProps: import("../core/renderer").InstanceProps, oldProps?: import("../core/renderer").InstanceProps, accumulative?: boolean) => void;
+declare const reconciler: import("react-reconciler").Reconciler<unknown, unknown, unknown, unknown, unknown>, applyProps: typeof import("../core/utils").applyProps;
 export declare type RenderProps<TCanvas extends Element> = Omit<StoreProps, 'gl' | 'events' | 'size'> & {
-    gl?: THREE.WebGLRenderer | THREE.WebGLRendererParameters;
+    gl?: THREE.WebGLRenderer | Partial<THREE.WebGLRendererParameters>;
     events?: (store: UseStore<RootState>) => EventManager<TCanvas>;
     size?: Size;
     onCreated?: (state: RootState) => void;
@@ -25,6 +25,6 @@ declare function dispose<TObj extends {
     [key: string]: any;
 }>(obj: TObj): void;
 declare const act: (callback: () => import("react-reconciler").Thenable<unknown>) => import("react-reconciler").Thenable<void>;
-declare function createPortal(children: React.ReactNode, container: THREE.Object3D, implementation?: any, key?: any): React.ReactNode;
+declare function createPortal(children: React.ReactNode, container: THREE.Object3D): React.ReactNode;
 export * from '../core/hooks';
 export { context, render, unmountComponentAtNode, createPortal, events, reconciler, applyProps, dispose, invalidate, advance, extend, addEffect, addAfterEffect, addTail, Canvas, act, roots as _roots, };