@react-three/fiber 9.0.0-rc.0 → 9.0.0-rc.10

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

@@ -1,212 +1,18 @@
-import { e as extend, u as useBridge, a as useMutableCallback, b as useIsomorphicLayoutEffect, c as createRoot, i as isRef, E as ErrorBoundary, B as Block, d as unmountComponentAtNode, f as createPointerEvents } from './events-5a08b43f.esm.js';
-export { t as ReactThreeFiber, _ as _roots, x as act, k as addAfterEffect, j as addEffect, l as addTail, n as advance, s as applyProps, y as buildGraph, q as context, g as createEvents, p as createPortal, c as createRoot, w as dispose, f as events, e as extend, h as flushGlobalEffects, v as getRootState, m as invalidate, r as reconciler, o as render, d as unmountComponentAtNode, D as useFrame, F as useGraph, z as useInstanceHandle, G as useLoader, A as useStore, C as useThree } from './events-5a08b43f.esm.js';
+import { e as extend, u as useBridge, a as useMutableCallback, b as useIsomorphicLayoutEffect, c as createRoot, i as isRef, E as ErrorBoundary, B as Block, d as unmountComponentAtNode, f as createPointerEvents } from './events-aba3c3d1.esm.js';
+export { t as ReactThreeFiber, _ as _roots, w as act, k as addAfterEffect, j as addEffect, l as addTail, n as advance, q as applyProps, x as buildGraph, p as context, g as createEvents, o as createPortal, c as createRoot, v as dispose, f as events, e as extend, h as flushGlobalEffects, s as getRootState, m as invalidate, r as reconciler, d as unmountComponentAtNode, C as useFrame, D as useGraph, y as useInstanceHandle, F as useLoader, z as useStore, A as useThree } from './events-aba3c3d1.esm.js';
 import * as React from 'react';
-import { useState, useRef, useEffect, useMemo } from 'react';
 import * as THREE from 'three';
-import createDebounce from 'debounce';
+import useMeasure from 'react-use-measure';
 import { FiberProvider } from 'its-fine';
 import { jsx } from 'react/jsx-runtime';
 import 'react-reconciler/constants';
 import 'zustand/traditional';
-import 'suspend-react';
 import 'react-reconciler';
 import 'scheduler';
+import 'suspend-react';
 
-/* eslint-disable react-hooks/rules-of-hooks */
-function useMeasure({
-  debounce,
-  scroll,
-  polyfill,
-  offsetSize
-} = {
-  debounce: 0,
-  scroll: false,
-  offsetSize: false
-}) {
-  const ResizeObserver = polyfill || typeof window !== 'undefined' && window.ResizeObserver;
-  const [bounds, set] = useState({
-    left: 0,
-    top: 0,
-    width: 0,
-    height: 0,
-    bottom: 0,
-    right: 0,
-    x: 0,
-    y: 0
-  });
-
-  // In test mode
-  if (!ResizeObserver) {
-    // @ts-ignore
-    bounds.width = 1280;
-    // @ts-ignore
-    bounds.height = 800;
-    return [() => {}, bounds, () => {}];
-  }
-
-  // keep all state in a ref
-  const state = useRef({
-    element: null,
-    scrollContainers: null,
-    resizeObserver: null,
-    lastBounds: bounds,
-    orientationHandler: null
-  });
-
-  // set actual debounce values early, so effects know if they should react accordingly
-  const scrollDebounce = debounce ? typeof debounce === 'number' ? debounce : debounce.scroll : null;
-  const resizeDebounce = debounce ? typeof debounce === 'number' ? debounce : debounce.resize : null;
-
-  // make sure to update state only as long as the component is truly mounted
-  const mounted = useRef(false);
-  useEffect(() => {
-    mounted.current = true;
-    return () => void (mounted.current = false);
-  });
-
-  // memoize handlers, so event-listeners know when they should update
-  const [forceRefresh, resizeChange, scrollChange] = useMemo(() => {
-    const callback = () => {
-      if (!state.current.element) return;
-      const {
-        left,
-        top,
-        width,
-        height,
-        bottom,
-        right,
-        x,
-        y
-      } = state.current.element.getBoundingClientRect();
-      const size = {
-        left,
-        top,
-        width,
-        height,
-        bottom,
-        right,
-        x,
-        y
-      };
-      if (state.current.element instanceof HTMLElement && offsetSize) {
-        size.height = state.current.element.offsetHeight;
-        size.width = state.current.element.offsetWidth;
-      }
-      Object.freeze(size);
-      if (mounted.current && !areBoundsEqual(state.current.lastBounds, size)) set(state.current.lastBounds = size);
-    };
-    return [callback, resizeDebounce ? createDebounce(callback, resizeDebounce) : callback, scrollDebounce ? createDebounce(callback, scrollDebounce) : callback];
-  }, [set, offsetSize, scrollDebounce, resizeDebounce]);
-
-  // cleanup current scroll-listeners / observers
-  function removeListeners() {
-    if (state.current.scrollContainers) {
-      state.current.scrollContainers.forEach(element => element.removeEventListener('scroll', scrollChange, true));
-      state.current.scrollContainers = null;
-    }
-    if (state.current.resizeObserver) {
-      state.current.resizeObserver.disconnect();
-      state.current.resizeObserver = null;
-    }
-    if (state.current.orientationHandler) {
-      if ('orientation' in screen && 'removeEventListener' in screen.orientation) {
-        screen.orientation.removeEventListener('change', state.current.orientationHandler);
-      } else if ('onorientationchange' in window) {
-        window.removeEventListener('orientationchange', state.current.orientationHandler);
-      }
-    }
-  }
-
-  // add scroll-listeners / observers
-  function addListeners() {
-    var _state$current$resize;
-    if (!state.current.element) return;
-    state.current.resizeObserver = new ResizeObserver(resizeChange);
-    (_state$current$resize = state.current.resizeObserver) == null ? void 0 : _state$current$resize.observe(state.current.element);
-    if (scroll && state.current.scrollContainers) {
-      state.current.scrollContainers.forEach(scrollContainer => scrollContainer.addEventListener('scroll', scrollChange, {
-        capture: true,
-        passive: true
-      }));
-    }
-
-    // Handle orientation changes
-    state.current.orientationHandler = () => {
-      scrollChange();
-    };
-
-    // Use screen.orientation if available
-    if ('orientation' in screen && 'addEventListener' in screen.orientation) {
-      screen.orientation.addEventListener('change', state.current.orientationHandler);
-    } else if ('onorientationchange' in window) {
-      // Fallback to orientationchange event
-      window.addEventListener('orientationchange', state.current.orientationHandler);
-    }
-  }
-
-  // the ref we expose to the user
-  const ref = node => {
-    if (!node || node === state.current.element) return;
-    removeListeners();
-    state.current.element = node;
-    state.current.scrollContainers = findScrollContainers(node);
-    addListeners();
-  };
-
-  // add general event listeners
-  useOnWindowScroll(scrollChange, Boolean(scroll));
-  useOnWindowResize(resizeChange);
-
-  // respond to changes that are relevant for the listeners
-  useEffect(() => {
-    removeListeners();
-    addListeners();
-  }, [scroll, scrollChange, resizeChange]);
-
-  // remove all listeners when the components unmounts
-  useEffect(() => removeListeners, []);
-  return [ref, bounds, forceRefresh];
-}
-
-// Adds native resize listener to window
-function useOnWindowResize(onWindowResize) {
-  useEffect(() => {
-    const cb = onWindowResize;
-    window.addEventListener('resize', cb);
-    return () => void window.removeEventListener('resize', cb);
-  }, [onWindowResize]);
-}
-function useOnWindowScroll(onScroll, enabled) {
-  useEffect(() => {
-    if (enabled) {
-      const cb = onScroll;
-      window.addEventListener('scroll', cb, {
-        capture: true,
-        passive: true
-      });
-      return () => void window.removeEventListener('scroll', cb, true);
-    }
-  }, [onScroll, enabled]);
-}
-
-// Returns a list of scroll offsets
-function findScrollContainers(element) {
-  const result = [];
-  if (!element || element === document.body) return result;
-  const {
-    overflow,
-    overflowX,
-    overflowY
-  } = window.getComputedStyle(element);
-  if ([overflow, overflowX, overflowY].some(prop => prop === 'auto' || prop === 'scroll')) result.push(element);
-  return [...result, ...findScrollContainers(element.parentElement)];
-}
-
-// Checks if element boundaries are equal
-const keys = ['x', 'y', 'top', 'bottom', 'left', 'right', 'width', 'height'];
-const areBoundsEqual = (a, b) => keys.every(key => a[key] === b[key]);
-
-const CanvasImpl = /*#__PURE__*/React.forwardRef(function Canvas({
+function CanvasImpl({
+  ref,
   children,
   fallback,
   resize,
@@ -229,7 +35,7 @@ const CanvasImpl = /*#__PURE__*/React.forwardRef(function Canvas({
   onPointerMissed,
   onCreated,
   ...props
-}, forwardedRef) {
+}) {
   // Create a known catalogue of Threejs-native elements
   // This will include the entire THREE namespace by default, users can extend
   // their own elements by using the createRoot API instead
@@ -245,7 +51,7 @@ const CanvasImpl = /*#__PURE__*/React.forwardRef(function Canvas({
   });
   const canvasRef = React.useRef(null);
   const divRef = React.useRef(null);
-  React.useImperativeHandle(forwardedRef, () => canvasRef.current);
+  React.useImperativeHandle(ref, () => canvasRef.current);
   const handlePointerMissed = useMutableCallback(onPointerMissed);
   const [block, setBlock] = React.useState(false);
   const [error, setError] = React.useState(false);
@@ -259,52 +65,55 @@ const CanvasImpl = /*#__PURE__*/React.forwardRef(function Canvas({
     const canvas = canvasRef.current;
     if (containerRect.width > 0 && containerRect.height > 0 && canvas) {
       if (!root.current) root.current = createRoot(canvas);
-      root.current.configure({
-        gl,
-        scene,
-        events,
-        shadows,
-        linear,
-        flat,
-        legacy,
-        orthographic,
-        frameloop,
-        dpr,
-        performance,
-        raycaster,
-        camera,
-        size: containerRect,
-        // Pass mutable reference to onPointerMissed so it's free to update
-        onPointerMissed: (...args) => handlePointerMissed.current == null ? void 0 : handlePointerMissed.current(...args),
-        onCreated: state => {
-          // Connect to event source
-          state.events.connect == null ? void 0 : state.events.connect(eventSource ? isRef(eventSource) ? eventSource.current : eventSource : divRef.current);
-          // Set up compute function
-          if (eventPrefix) {
-            state.setEvents({
-              compute: (event, state) => {
-                const x = event[eventPrefix + 'X'];
-                const y = event[eventPrefix + 'Y'];
-                state.pointer.set(x / state.size.width * 2 - 1, -(y / state.size.height) * 2 + 1);
-                state.raycaster.setFromCamera(state.pointer, state.camera);
-              }
-            });
+      async function run() {
+        await root.current.configure({
+          gl,
+          scene,
+          events,
+          shadows,
+          linear,
+          flat,
+          legacy,
+          orthographic,
+          frameloop,
+          dpr,
+          performance,
+          raycaster,
+          camera,
+          size: containerRect,
+          // Pass mutable reference to onPointerMissed so it's free to update
+          onPointerMissed: (...args) => handlePointerMissed.current == null ? void 0 : handlePointerMissed.current(...args),
+          onCreated: state => {
+            // Connect to event source
+            state.events.connect == null ? void 0 : state.events.connect(eventSource ? isRef(eventSource) ? eventSource.current : eventSource : divRef.current);
+            // Set up compute function
+            if (eventPrefix) {
+              state.setEvents({
+                compute: (event, state) => {
+                  const x = event[eventPrefix + 'X'];
+                  const y = event[eventPrefix + 'Y'];
+                  state.pointer.set(x / state.size.width * 2 - 1, -(y / state.size.height) * 2 + 1);
+                  state.raycaster.setFromCamera(state.pointer, state.camera);
+                }
+              });
+            }
+            // Call onCreated callback
+            onCreated == null ? void 0 : onCreated(state);
           }
-          // Call onCreated callback
-          onCreated == null ? void 0 : onCreated(state);
-        }
-      });
-      root.current.render( /*#__PURE__*/jsx(Bridge, {
-        children: /*#__PURE__*/jsx(ErrorBoundary, {
-          set: setError,
-          children: /*#__PURE__*/jsx(React.Suspense, {
-            fallback: /*#__PURE__*/jsx(Block, {
-              set: setBlock
-            }),
-            children: children
+        });
+        root.current.render( /*#__PURE__*/jsx(Bridge, {
+          children: /*#__PURE__*/jsx(ErrorBoundary, {
+            set: setError,
+            children: /*#__PURE__*/jsx(React.Suspense, {
+              fallback: /*#__PURE__*/jsx(Block, {
+                set: setBlock
+              }),
+              children: children
+            })
           })
-        })
-      }));
+        }));
+      }
+      run();
     }
   });
   React.useEffect(() => {
@@ -341,19 +150,18 @@ const CanvasImpl = /*#__PURE__*/React.forwardRef(function Canvas({
       })
     })
   });
-});
+}
 
 /**
  * A DOM canvas which accepts threejs elements as children.
  * @see https://docs.pmnd.rs/react-three-fiber/api/canvas
  */
-const Canvas = /*#__PURE__*/React.forwardRef(function CanvasWrapper(props, ref) {
+function Canvas(props) {
   return /*#__PURE__*/jsx(FiberProvider, {
     children: /*#__PURE__*/jsx(CanvasImpl, {
-      ...props,
-      ref: ref
+      ...props
     })
   });
-});
+}
 
 export { Canvas };

package/native/dist/react-three-fiber-native.cjs.dev.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var events = require('../../dist/events-fa0fb3db.cjs.dev.js');
+var events = require('../../dist/events-b02714fc.cjs.dev.js');
 var React = require('react');
 var THREE = require('three');
 var reactNative = require('react-native');
@@ -15,9 +15,9 @@ var base64Js = require('base64-js');
 var buffer = require('buffer');
 require('react-reconciler/constants');
 require('zustand/traditional');
-require('suspend-react');
 require('react-reconciler');
 require('scheduler');
+require('suspend-react');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -43,11 +43,7 @@ var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 
 // TODO: React 19 needs support from react-native
 const _View = reactNative.View;
-/**
- * A native canvas which accepts threejs elements as children.
- * @see https://docs.pmnd.rs/react-three-fiber/api/canvas
- */
-const CanvasImpl = /*#__PURE__*/React__namespace.forwardRef(({
+function CanvasImpl({
   children,
   style,
   gl,
@@ -64,8 +60,9 @@ const CanvasImpl = /*#__PURE__*/React__namespace.forwardRef(({
   scene,
   onPointerMissed,
   onCreated,
+  ref,
   ...props
-}, forwardedRef) => {
+}) {
   // Create a known catalogue of Threejs-native elements
   // This will include the entire THREE namespace by default, users can extend
   // their own elements by using the createRoot API instead
@@ -84,7 +81,7 @@ const CanvasImpl = /*#__PURE__*/React__namespace.forwardRef(({
   });
   const [canvas, setCanvas] = React__namespace.useState(null);
   const [bind, setBind] = React__namespace.useState();
-  React__namespace.useImperativeHandle(forwardedRef, () => viewRef.current);
+  React__namespace.useImperativeHandle(ref, () => viewRef.current);
   const handlePointerMissed = events.useMutableCallback(onPointerMissed);
   const [block, setBlock] = React__namespace.useState(false);
   const [error, setError] = React__namespace.useState(undefined);
@@ -196,55 +193,60 @@ const CanvasImpl = /*#__PURE__*/React__namespace.forwardRef(({
     });
     setBind(responder.panHandlers);
   }, []);
-  if (root.current && width > 0 && height > 0) {
-    root.current.configure({
-      gl,
-      events: events$1,
-      shadows,
-      linear,
-      flat,
-      legacy,
-      orthographic,
-      frameloop,
-      performance,
-      raycaster,
-      camera,
-      scene,
-      // expo-gl can only render at native dpr/resolution
-      // https://github.com/expo/expo-three/issues/39
-      dpr: reactNative.PixelRatio.get(),
-      size: {
-        width,
-        height,
-        top,
-        left
-      },
-      // Pass mutable reference to onPointerMissed so it's free to update
-      onPointerMissed: (...args) => handlePointerMissed.current == null ? void 0 : handlePointerMissed.current(...args),
-      // Overwrite onCreated to apply RN bindings
-      onCreated: state => {
-        // Bind render to RN bridge
-        const context = state.gl.getContext();
-        const renderFrame = state.gl.render.bind(state.gl);
-        state.gl.render = (scene, camera) => {
-          renderFrame(scene, camera);
-          context.endFrameEXP();
-        };
-        return onCreated == null ? void 0 : onCreated(state);
+  events.useIsomorphicLayoutEffect(() => {
+    if (root.current && width > 0 && height > 0) {
+      async function run() {
+        await root.current.configure({
+          gl,
+          events: events$1,
+          shadows,
+          linear,
+          flat,
+          legacy,
+          orthographic,
+          frameloop,
+          performance,
+          raycaster,
+          camera,
+          scene,
+          // expo-gl can only render at native dpr/resolution
+          // https://github.com/expo/expo-three/issues/39
+          dpr: reactNative.PixelRatio.get(),
+          size: {
+            width,
+            height,
+            top,
+            left
+          },
+          // Pass mutable reference to onPointerMissed so it's free to update
+          onPointerMissed: (...args) => handlePointerMissed.current == null ? void 0 : handlePointerMissed.current(...args),
+          // Overwrite onCreated to apply RN bindings
+          onCreated: state => {
+            // Bind render to RN bridge
+            const context = state.gl.getContext();
+            const renderFrame = state.gl.render.bind(state.gl);
+            state.gl.render = (scene, camera) => {
+              renderFrame(scene, camera);
+              context.endFrameEXP();
+            };
+            return onCreated == null ? void 0 : onCreated(state);
+          }
+        });
+        root.current.render( /*#__PURE__*/jsxRuntime.jsx(Bridge, {
+          children: /*#__PURE__*/jsxRuntime.jsx(events.ErrorBoundary, {
+            set: setError,
+            children: /*#__PURE__*/jsxRuntime.jsx(React__namespace.Suspense, {
+              fallback: /*#__PURE__*/jsxRuntime.jsx(events.Block, {
+                set: setBlock
+              }),
+              children: children
+            })
+          })
+        }));
       }
-    });
-    root.current.render( /*#__PURE__*/jsxRuntime.jsx(Bridge, {
-      children: /*#__PURE__*/jsxRuntime.jsx(events.ErrorBoundary, {
-        set: setError,
-        children: /*#__PURE__*/jsxRuntime.jsx(React__namespace.Suspense, {
-          fallback: /*#__PURE__*/jsxRuntime.jsx(events.Block, {
-            set: setBlock
-          }),
-          children: children
-        })
-      })
-    }));
-  }
+      run();
+    }
+  });
   React__namespace.useEffect(() => {
     if (canvas) {
       return () => events.unmountComponentAtNode(canvas);
@@ -265,20 +267,19 @@ const CanvasImpl = /*#__PURE__*/React__namespace.forwardRef(({
       style: reactNative.StyleSheet.absoluteFill
     })
   });
-});
+}
 
 /**
  * A native canvas which accepts threejs elements as children.
  * @see https://docs.pmnd.rs/react-three-fiber/api/canvas
  */
-const Canvas = /*#__PURE__*/React__namespace.forwardRef(function CanvasWrapper(props, ref) {
+function Canvas(props) {
   return /*#__PURE__*/jsxRuntime.jsx(itsFine.FiberProvider, {
     children: /*#__PURE__*/jsxRuntime.jsx(CanvasImpl, {
-      ...props,
-      ref: ref
+      ...props
     })
   });
-});
+}
 
 /** Default R3F event manager for react-native */
 function createTouchEvents(store) {
@@ -542,7 +543,6 @@ exports.flushGlobalEffects = events.flushGlobalEffects;
 exports.getRootState = events.getRootState;
 exports.invalidate = events.invalidate;
 exports.reconciler = events.reconciler;
-exports.render = events.render;
 exports.unmountComponentAtNode = events.unmountComponentAtNode;
 exports.useFrame = events.useFrame;
 exports.useGraph = events.useGraph;