@react-three/fiber 8.16.8 → 8.17.1

package/native/dist/react-three-fiber-native.esm.js

@@ -1,5 +1,5 @@
-import { c as createEvents, e as extend, u as useMutableCallback, b as createRoot, E as ErrorBoundary, B as Block, d as unmountComponentAtNode } from '../../dist/index-99983b2d.esm.js';
-export { t as ReactThreeFiber, x as _roots, v as act, o as addAfterEffect, n as addEffect, p as addTail, m as advance, j as applyProps, w as buildGraph, f as context, c as createEvents, g as createPortal, b as createRoot, k as dispose, e as extend, q as flushGlobalEffects, s as getRootState, l as invalidate, h as reconciler, r as render, d as unmountComponentAtNode, C as useFrame, D as useGraph, y as useInstanceHandle, F as useLoader, z as useStore, A as useThree } from '../../dist/index-99983b2d.esm.js';
+import { c as createPointerEvents, e as extend, u as useMutableCallback, b as createRoot, E as ErrorBoundary, B as Block, d as unmountComponentAtNode, f as createEvents } from '../../dist/events-3515660a.esm.js';
+export { t as ReactThreeFiber, z as _roots, x as act, p as addAfterEffect, o as addEffect, q as addTail, n as advance, k as applyProps, y as buildGraph, g as context, f as createEvents, c as createPointerEvents, h as createPortal, b as createRoot, l as dispose, e as extend, s as flushGlobalEffects, v as flushSync, w as getRootState, m as invalidate, j as reconciler, r as render, d as unmountComponentAtNode, F as useFrame, G as useGraph, A as useInstanceHandle, H as useLoader, C as useStore, D as useThree } from '../../dist/events-3515660a.esm.js';
 import * as React from 'react';
 import * as THREE from 'three';
 import { PanResponder, PixelRatio, View, StyleSheet, Platform, Image, NativeModules } from 'react-native';
@@ -12,91 +12,9 @@ import { fromByteArray } from 'base64-js';
 import { Buffer } from 'buffer';
 import 'react-reconciler/constants';
 import 'zustand';
+import 'suspend-react';
 import 'react-reconciler';
 import 'scheduler';
-import 'suspend-react';
-
-/** Default R3F event manager for react-native */
-function createTouchEvents(store) {
-  const {
-    handlePointer
-  } = createEvents(store);
-  const handleTouch = (event, name) => {
-    event.persist()
-
-    // Apply offset
-    ;
-    event.nativeEvent.offsetX = event.nativeEvent.locationX;
-    event.nativeEvent.offsetY = event.nativeEvent.locationY;
-
-    // Emulate DOM event
-    const callback = handlePointer(name);
-    callback(event.nativeEvent);
-    return true;
-  };
-  const responder = PanResponder.create({
-    onStartShouldSetPanResponder: () => true,
-    onMoveShouldSetPanResponder: () => true,
-    onMoveShouldSetPanResponderCapture: () => true,
-    onPanResponderTerminationRequest: () => true,
-    onStartShouldSetPanResponderCapture: e => handleTouch(e, 'onPointerCapture'),
-    onPanResponderStart: e => handleTouch(e, 'onPointerDown'),
-    onPanResponderMove: e => handleTouch(e, 'onPointerMove'),
-    onPanResponderEnd: (e, state) => {
-      handleTouch(e, 'onPointerUp');
-      if (Math.hypot(state.dx, state.dy) < 20) handleTouch(e, 'onClick');
-    },
-    onPanResponderRelease: e => handleTouch(e, 'onPointerLeave'),
-    onPanResponderTerminate: e => handleTouch(e, 'onLostPointerCapture'),
-    onPanResponderReject: e => handleTouch(e, 'onLostPointerCapture')
-  });
-  return {
-    priority: 1,
-    enabled: true,
-    compute(event, state, previous) {
-      // https://github.com/pmndrs/react-three-fiber/pull/782
-      // Events trigger outside of canvas when moved, use offsetX/Y by default and allow overrides
-      state.pointer.set(event.offsetX / state.size.width * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
-      state.raycaster.setFromCamera(state.pointer, state.camera);
-    },
-    connected: undefined,
-    handlers: responder.panHandlers,
-    update: () => {
-      var _internal$lastEvent;
-      const {
-        events,
-        internal
-      } = store.getState();
-      if ((_internal$lastEvent = internal.lastEvent) != null && _internal$lastEvent.current && events.handlers) {
-        handlePointer('onPointerMove')(internal.lastEvent.current);
-      }
-    },
-    connect: () => {
-      const {
-        set,
-        events
-      } = store.getState();
-      events.disconnect == null ? void 0 : events.disconnect();
-      set(state => ({
-        events: {
-          ...state.events,
-          connected: true
-        }
-      }));
-    },
-    disconnect: () => {
-      const {
-        set
-      } = store.getState();
-      set(state => ({
-        events: {
-          ...state.events,
-          connected: false
-        }
-      }));
-    }
-  };
-}
 
 /**
  * A native canvas which accepts threejs elements as children.
@@ -106,7 +24,7 @@ const CanvasImpl = /*#__PURE__*/React.forwardRef(({
   children,
   style,
   gl,
-  events = createTouchEvents,
+  events = createPointerEvents,
   shadows,
   linear,
   flat,
@@ -169,22 +87,86 @@ const CanvasImpl = /*#__PURE__*/React.forwardRef(({
   // Called on context create or swap
   // https://github.com/pmndrs/react-three-fiber/pull/2297
   const onContextCreate = React.useCallback(context => {
-    const canvasShim = {
+    const listeners = new Map();
+    const canvas = {
+      style: {},
       width: context.drawingBufferWidth,
       height: context.drawingBufferHeight,
-      style: {},
-      addEventListener: () => {},
-      removeEventListener: () => {},
+      clientWidth: context.drawingBufferWidth,
       clientHeight: context.drawingBufferHeight,
       getContext: (_, {
         antialias = false
       }) => {
         setAntialias(antialias);
         return context;
+      },
+      addEventListener(type, listener) {
+        let callbacks = listeners.get(type);
+        if (!callbacks) {
+          callbacks = [];
+          listeners.set(type, callbacks);
+        }
+        callbacks.push(listener);
+      },
+      removeEventListener(type, listener) {
+        const callbacks = listeners.get(type);
+        if (callbacks) {
+          const index = callbacks.indexOf(listener);
+          if (index !== -1) callbacks.splice(index, 1);
+        }
+      },
+      dispatchEvent(event) {
+        Object.assign(event, {
+          target: this
+        });
+        const callbacks = listeners.get(event.type);
+        if (callbacks) {
+          for (const callback of callbacks) {
+            callback(event);
+          }
+        }
+      },
+      setPointerCapture() {
+        // TODO
+      },
+      releasePointerCapture() {
+        // TODO
       }
     };
-    root.current = createRoot(canvasShim);
-    setCanvas(canvasShim);
+
+    // TODO: this is wrong but necessary to trick controls
+    // @ts-ignore
+    canvas.ownerDocument = canvas;
+    canvas.getRootNode = () => canvas;
+    root.current = createRoot(canvas);
+    setCanvas(canvas);
+    function handleTouch(gestureEvent, type) {
+      gestureEvent.persist();
+      canvas.dispatchEvent(Object.assign(gestureEvent.nativeEvent, {
+        type,
+        offsetX: gestureEvent.nativeEvent.locationX,
+        offsetY: gestureEvent.nativeEvent.locationY,
+        pointerType: 'touch'
+      }));
+      return true;
+    }
+    const responder = PanResponder.create({
+      onStartShouldSetPanResponder: () => true,
+      onMoveShouldSetPanResponder: () => true,
+      onMoveShouldSetPanResponderCapture: () => true,
+      onPanResponderTerminationRequest: () => true,
+      onStartShouldSetPanResponderCapture: e => handleTouch(e, 'pointercapture'),
+      onPanResponderStart: e => handleTouch(e, 'pointerdown'),
+      onPanResponderMove: e => handleTouch(e, 'pointermove'),
+      onPanResponderEnd: (e, state) => {
+        handleTouch(e, 'pointerup');
+        if (Math.hypot(state.dx, state.dy) < 20) handleTouch(e, 'click');
+      },
+      onPanResponderRelease: e => handleTouch(e, 'pointerleave'),
+      onPanResponderTerminate: e => handleTouch(e, 'lostpointercapture'),
+      onPanResponderReject: e => handleTouch(e, 'lostpointercapture')
+    });
+    setBind(responder.panHandlers);
   }, []);
   if (root.current && width > 0 && height > 0) {
     root.current.configure({
@@ -213,9 +195,6 @@ const CanvasImpl = /*#__PURE__*/React.forwardRef(({
       onPointerMissed: (...args) => handlePointerMissed.current == null ? void 0 : handlePointerMissed.current(...args),
       // Overwrite onCreated to apply RN bindings
       onCreated: state => {
-        // Bind events after creation
-        setBind(state.events.handlers);
-
         // Bind render to RN bridge
         const context = state.gl.getContext();
         const renderFrame = state.gl.render.bind(state.gl);
@@ -244,18 +223,23 @@ const CanvasImpl = /*#__PURE__*/React.forwardRef(({
     }
   }, [canvas]);
   return /*#__PURE__*/jsx(View, {
-    ...props,
     ref: viewRef,
     onLayout: onLayout,
     style: {
       flex: 1,
       ...style
     },
-    ...bind,
-    children: width > 0 && /*#__PURE__*/jsx(GLView, {
-      msaaSamples: antialias ? 4 : 0,
-      onContextCreate: onContextCreate,
-      style: StyleSheet.absoluteFill
+    children: /*#__PURE__*/jsx(View, {
+      ...props,
+      style: {
+        flex: 1
+      },
+      children: width > 0 && /*#__PURE__*/jsx(GLView, {
+        ...bind,
+        msaaSamples: antialias ? 4 : 0,
+        onContextCreate: onContextCreate,
+        style: StyleSheet.absoluteFill
+      })
     })
   });
 });
@@ -273,6 +257,88 @@ const Canvas = /*#__PURE__*/React.forwardRef(function CanvasWrapper(props, ref)
   });
 });
 
+/** Default R3F event manager for react-native */
+function createTouchEvents(store) {
+  const {
+    handlePointer
+  } = createEvents(store);
+  const handleTouch = (event, name) => {
+    event.persist()
+
+    // Apply offset
+    ;
+    event.nativeEvent.offsetX = event.nativeEvent.locationX;
+    event.nativeEvent.offsetY = event.nativeEvent.locationY;
+
+    // Emulate DOM event
+    const callback = handlePointer(name);
+    callback(event.nativeEvent);
+    return true;
+  };
+  const responder = PanResponder.create({
+    onStartShouldSetPanResponder: () => true,
+    onMoveShouldSetPanResponder: () => true,
+    onMoveShouldSetPanResponderCapture: () => true,
+    onPanResponderTerminationRequest: () => true,
+    onStartShouldSetPanResponderCapture: e => handleTouch(e, 'onPointerCapture'),
+    onPanResponderStart: e => handleTouch(e, 'onPointerDown'),
+    onPanResponderMove: e => handleTouch(e, 'onPointerMove'),
+    onPanResponderEnd: (e, state) => {
+      handleTouch(e, 'onPointerUp');
+      if (Math.hypot(state.dx, state.dy) < 20) handleTouch(e, 'onClick');
+    },
+    onPanResponderRelease: e => handleTouch(e, 'onPointerLeave'),
+    onPanResponderTerminate: e => handleTouch(e, 'onLostPointerCapture'),
+    onPanResponderReject: e => handleTouch(e, 'onLostPointerCapture')
+  });
+  return {
+    priority: 1,
+    enabled: true,
+    compute(event, state, previous) {
+      // https://github.com/pmndrs/react-three-fiber/pull/782
+      // Events trigger outside of canvas when moved, use offsetX/Y by default and allow overrides
+      state.pointer.set(event.offsetX / state.size.width * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
+      state.raycaster.setFromCamera(state.pointer, state.camera);
+    },
+    connected: undefined,
+    handlers: responder.panHandlers,
+    update: () => {
+      var _internal$lastEvent;
+      const {
+        events,
+        internal
+      } = store.getState();
+      if ((_internal$lastEvent = internal.lastEvent) != null && _internal$lastEvent.current && events.handlers) {
+        handlePointer('onPointerMove')(internal.lastEvent.current);
+      }
+    },
+    connect: () => {
+      const {
+        set,
+        events
+      } = store.getState();
+      events.disconnect == null ? void 0 : events.disconnect();
+      set(state => ({
+        events: {
+          ...state.events,
+          connected: true
+        }
+      }));
+    },
+    disconnect: () => {
+      const {
+        set
+      } = store.getState();
+      set(state => ({
+        events: {
+          ...state.events,
+          connected: false
+        }
+      }));
+    }
+  };
+}
+
 // http://stackoverflow.com/questions/105034
 function uuidv4() {
   return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-three/fiber",
-  "version": "8.16.8",
+  "version": "8.17.1",
   "description": "A React renderer for Threejs",
   "keywords": [
     "react",
@@ -43,13 +43,14 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.17.8",
+    "@types/debounce": "^1.2.1",
     "@types/react-reconciler": "^0.26.7",
     "@types/webxr": "*",
     "base64-js": "^1.5.1",
     "buffer": "^6.0.3",
+    "debounce": "^1.2.1",
     "its-fine": "^1.0.6",
     "react-reconciler": "^0.27.0",
-    "react-use-measure": "^2.1.1",
     "scheduler": "^0.21.0",
     "suspend-react": "^0.1.3",
     "zustand": "^3.7.1"

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

@@ -1,93 +0,0 @@
-import * as THREE from 'three';
-import type { UseBoundStore } from 'zustand';
-import type { RootState } from './store';
-import type { Properties } from '../three-types';
-export interface Intersection extends THREE.Intersection {
-    /** The event source (the object which registered the handler) */
-    eventObject: THREE.Object3D;
-}
-export interface IntersectionEvent<TSourceEvent> extends Intersection {
-    /** The event source (the object which registered the handler) */
-    eventObject: THREE.Object3D;
-    /** An array of intersections */
-    intersections: Intersection[];
-    /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */
-    unprojectedPoint: THREE.Vector3;
-    /** Normalized event coordinates */
-    pointer: THREE.Vector2;
-    /** Delta between first click and this event */
-    delta: number;
-    /** The ray that pierced it */
-    ray: THREE.Ray;
-    /** The camera that was used by the raycaster */
-    camera: Camera;
-    /** stopPropagation will stop underlying handlers from firing */
-    stopPropagation: () => void;
-    /** The original host event */
-    nativeEvent: TSourceEvent;
-    /** If the event was stopped by calling stopPropagation */
-    stopped: boolean;
-}
-export declare type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
-export declare type ThreeEvent<TEvent> = IntersectionEvent<TEvent> & Properties<TEvent>;
-export declare type DomEvent = PointerEvent | MouseEvent | WheelEvent;
-export declare type Events = {
-    onClick: EventListener;
-    onContextMenu: EventListener;
-    onDoubleClick: EventListener;
-    onWheel: EventListener;
-    onPointerDown: EventListener;
-    onPointerUp: EventListener;
-    onPointerLeave: EventListener;
-    onPointerMove: EventListener;
-    onPointerCancel: EventListener;
-    onLostPointerCapture: EventListener;
-};
-export declare type EventHandlers = {
-    onClick?: (event: ThreeEvent<MouseEvent>) => void;
-    onContextMenu?: (event: ThreeEvent<MouseEvent>) => void;
-    onDoubleClick?: (event: ThreeEvent<MouseEvent>) => void;
-    onPointerUp?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerDown?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerOver?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerOut?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerEnter?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerLeave?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerMove?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerMissed?: (event: MouseEvent) => void;
-    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> {
-    /** Determines if the event layer is active */
-    enabled: boolean;
-    /** Event layer priority, higher prioritized layers come first and may stop(-propagate) lower layer  */
-    priority: number;
-    /** The compute function needs to set up the raycaster and an xy- pointer  */
-    compute?: ComputeFunction;
-    /** The filter can re-order or re-structure the intersections  */
-    filter?: FilterFunction;
-    /** The target node the event layer is tied to */
-    connected?: TTarget;
-    /** All the pointer event handlers through which the host forwards native events */
-    handlers?: Events;
-    /** Allows re-connecting to another target */
-    connect?: (target: TTarget) => void;
-    /** Removes all existing events handlers from the target */
-    disconnect?: () => void;
-    /** Triggers a onPointerMove with the last known event. This can be useful to enable raycasting without
-     *  explicit user interaction, for instance when the camera moves a hoverable object underneath the cursor.
-     */
-    update?: () => void;
-}
-export interface PointerCaptureTarget {
-    intersection: Intersection;
-    target: Element;
-}
-export declare function getEventPriority(): 1 | 16 | 4;
-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,57 +0,0 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import { StateSelector, EqualityChecker } from 'zustand';
-import { RootState, RenderCallback } from './store';
-import { ObjectMap } from './utils';
-import { LocalState } from './renderer';
-export interface Loader<T> extends THREE.Loader {
-    load(url: string, onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: unknown) => void): unknown;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<T>;
-}
-export declare type LoaderProto<T> = new (...args: any) => Loader<T extends unknown ? any : T>;
-export declare type LoaderReturnType<T, L extends LoaderProto<T>> = T extends unknown ? Awaited<ReturnType<InstanceType<L>['loadAsync']>> : T;
-export declare type LoaderResult<T> = T extends any[] ? Loader<T[number]> : Loader<T>;
-export declare type Extensions<T extends {
-    prototype: LoaderProto<any>;
-}> = (loader: T['prototype']) => void;
-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>;
-/**
- * Exposes an object's {@link LocalState}.
- * @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.
- */
-export declare function useInstanceHandle<O>(ref: React.MutableRefObject<O>): React.MutableRefObject<LocalState>;
-export declare function useStore(): import("zustand").UseBoundStore<RootState, import("zustand").StoreApi<RootState>>;
-/**
- * Accesses R3F's internal state, containing renderer, canvas, scene, etc.
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usethree
- */
-export declare function useThree<T = RootState>(selector?: StateSelector<RootState, T>, equalityFn?: EqualityChecker<T>): T;
-/**
- * Executes a callback before render in a shared frame loop.
- * Can order effects with render priority or manually render with a positive priority.
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe
- */
-export declare function useFrame(callback: RenderCallback, renderPriority?: number): null;
-/**
- * Returns a node graph of an object with named nodes & materials.
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usegraph
- */
-export declare function useGraph(object: THREE.Object3D): ObjectMap;
-declare type GLTFLike = {
-    scene: THREE.Object3D;
-};
-/**
- * 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[], L extends LoaderProto<T>, R = LoaderReturnType<T, L>>(Proto: L, input: U, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void): U extends any[] ? BranchingReturn<R, GLTFLike, R & ObjectMap>[] : BranchingReturn<R, GLTFLike, R & ObjectMap>;
-export declare namespace useLoader {
-    var preload: <T, U extends string | string[], L extends LoaderProto<T>>(Proto: L, input: U, extensions?: Extensions<L> | undefined) => undefined;
-    var clear: <T, U extends string | string[], L extends LoaderProto<T>>(Proto: L, input: U) => void;
-}
-export {};

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

@@ -1,87 +0,0 @@
-/// <reference types="offscreencanvas" />
-import * as THREE from 'three';
-import * as React from 'react';
-import { UseBoundStore } from 'zustand';
-import * as ReactThreeFiber from '../three-types';
-import { Renderer, context, RootState, Size, Dpr, Performance, PrivateKeys } from './store';
-import { extend, Root } from './renderer';
-import { addEffect, addAfterEffect, addTail, flushGlobalEffects, Invalidate, Advance } from './loop';
-import { EventManager, ComputeFunction } from './events';
-import { dispose, getRootState, Camera, buildGraph } from './utils';
-import type { Properties } from '../three-types';
-declare type Canvas = HTMLCanvasElement | OffscreenCanvas;
-declare const roots: Map<Canvas, Root>;
-declare const invalidate: Invalidate, advance: Advance;
-declare const reconciler: import("react-reconciler").Reconciler<UseBoundStore<RootState, import("zustand").StoreApi<RootState>>, import("./renderer").Instance, void, import("./renderer").Instance, import("./renderer").Instance>, applyProps: typeof import("./utils").applyProps;
-declare type GLProps = Renderer | ((canvas: Canvas) => Renderer) | Partial<Properties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters> | undefined;
-export declare type RenderProps<TCanvas extends Canvas> = {
-    /** A threejs renderer instance or props that go into the default renderer */
-    gl?: GLProps;
-    /** Dimensions to fit the renderer to. Will measure canvas dimensions if omitted */
-    size?: Size;
-    /**
-     * Enables shadows (by default PCFsoft). Can accept `gl.shadowMap` options for fine-tuning,
-     * but also strings: 'basic' | 'percentage' | 'soft' | 'variance'.
-     * @see https://threejs.org/docs/#api/en/renderers/WebGLRenderer.shadowMap
-     */
-    shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<THREE.WebGLShadowMap>;
-    /**
-     * Disables three r139 color management.
-     * @see https://threejs.org/docs/#manual/en/introduction/Color-management
-     */
-    legacy?: boolean;
-    /** Switch off automatic sRGB color space and gamma correction */
-    linear?: boolean;
-    /** Use `THREE.NoToneMapping` instead of `THREE.ACESFilmicToneMapping` */
-    flat?: boolean;
-    /** Creates an orthographic camera */
-    orthographic?: boolean;
-    /**
-     * R3F's render mode. Set to `demand` to only render on state change or `never` to take control.
-     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#on-demand-rendering
-     */
-    frameloop?: 'always' | 'demand' | 'never';
-    /**
-     * R3F performance options for adaptive performance.
-     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#movement-regression
-     */
-    performance?: Partial<Omit<Performance, 'regress'>>;
-    /** Target pixel ratio. Can clamp between a range: `[min, max]` */
-    dpr?: Dpr;
-    /** Props that go into the default raycaster */
-    raycaster?: Partial<THREE.Raycaster>;
-    /** A `THREE.Scene` instance or props that go into the default scene */
-    scene?: THREE.Scene | Partial<ReactThreeFiber.Object3DNode<THREE.Scene, typeof THREE.Scene>>;
-    /** A `THREE.Camera` instance or props that go into the default camera */
-    camera?: (Camera | Partial<ReactThreeFiber.Object3DNode<THREE.Camera, typeof THREE.Camera> & ReactThreeFiber.Object3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera> & ReactThreeFiber.Object3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>>) & {
-        /** Flags the camera as manual, putting projection into your own hands */
-        manual?: boolean;
-    };
-    /** An R3F event manager to manage elements' pointer events */
-    events?: (store: UseBoundStore<RootState>) => EventManager<HTMLElement>;
-    /** Callback after the canvas has rendered (but not yet committed) */
-    onCreated?: (state: RootState) => void;
-    /** Response for pointer clicks that have missed any target */
-    onPointerMissed?: (event: MouseEvent) => void;
-};
-export declare type ReconcilerRoot<TCanvas extends Canvas> = {
-    configure: (config?: RenderProps<TCanvas>) => ReconcilerRoot<TCanvas>;
-    render: (element: React.ReactNode) => UseBoundStore<RootState>;
-    unmount: () => void;
-};
-declare function createRoot<TCanvas extends Canvas>(canvas: TCanvas): ReconcilerRoot<TCanvas>;
-declare function render<TCanvas extends Canvas>(children: React.ReactNode, canvas: TCanvas, config: RenderProps<TCanvas>): UseBoundStore<RootState>;
-declare function unmountComponentAtNode<TCanvas extends Canvas>(canvas: TCanvas, callback?: (canvas: TCanvas) => void): void;
-export declare type InjectState = Partial<Omit<RootState, PrivateKeys> & {
-    events?: {
-        enabled?: boolean;
-        priority?: number;
-        compute?: ComputeFunction;
-        connected?: any;
-    };
-    size?: Size;
-}>;
-declare function createPortal(children: React.ReactNode, container: THREE.Object3D, state?: InjectState): JSX.Element;
-declare const act: any;
-export * from './hooks';
-export { context, render, createRoot, unmountComponentAtNode, createPortal, reconciler, applyProps, dispose, invalidate, advance, extend, addEffect, addAfterEffect, addTail, flushGlobalEffects, getRootState, act, buildGraph, roots as _roots, };

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

@@ -1,38 +0,0 @@
-import { Root } from './renderer';
-import { RootState } from './store';
-import { _XRFrame } from './utils';
-export declare type GlobalRenderCallback = (timeStamp: number) => void;
-/**
- * Adds a global render callback which is called each frame.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
- */
-export declare const addEffect: (callback: GlobalRenderCallback) => () => void;
-/**
- * Adds a global after-render callback which is called each frame.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
- */
-export declare const addAfterEffect: (callback: GlobalRenderCallback) => () => void;
-/**
- * Adds a global callback which is called when rendering stops.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
- */
-export declare const addTail: (callback: GlobalRenderCallback) => () => void;
-export declare type GlobalEffectType = 'before' | 'after' | 'tail';
-export declare function flushGlobalEffects(type: GlobalEffectType, timestamp: number): void;
-export declare type Invalidate = (state?: RootState, frames?: number) => void;
-export declare type Advance = (timestamp: number, runGlobalEffects?: boolean, state?: RootState, frame?: _XRFrame) => void;
-interface Loop {
-    loop: (timestamp: number) => void;
-    /**
-     * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.
-     * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate
-     */
-    invalidate: Invalidate;
-    /**
-     * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop="never"`.
-     * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
-     */
-    advance: Advance;
-}
-export declare function createLoop<TCanvas>(roots: Map<TCanvas, Root>): Loop;
-export {};