@react-three/fiber 10.0.0-canary.5c62eb9 → 10.0.0-canary.6d6e5ab

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.mjs CHANGED
@@ -1,6 +1,6 @@
1
1
  import * as webgpu from 'three/webgpu';
2
- import { RenderTarget, CubeReflectionMapping, EquirectangularReflectionMapping, CubeTextureLoader, Scene, WebGLCubeRenderTarget, HalfFloatType, Color, Frustum, Matrix4, Group, BoxGeometry, MeshBasicNodeMaterial, Mesh, Node, NodeUpdateType, Layers, SRGBColorSpace, RGBAFormat, UnsignedByteType, Vector3, Vector2, TextureLoader, Texture as Texture$1, CanvasTarget, Raycaster, OrthographicCamera, PerspectiveCamera, PCFShadowMap, VSMShadowMap, BasicShadowMap, ACESFilmicToneMapping, WebGPURenderer } from 'three/webgpu';
3
- import { WebGLRenderTarget, WebGLRenderer } from 'three';
2
+ import { CubeRenderTarget, RenderTarget, CubeReflectionMapping, EquirectangularReflectionMapping, CubeTextureLoader, Scene, HalfFloatType, Color, Frustum, Matrix4, Group, BoxGeometry, MeshBasicNodeMaterial, Mesh, Node, NodeUpdateType, Layers, ShaderMaterial, Uniform, SRGBColorSpace, RGBAFormat, UnsignedByteType, Vector3, Vector2, TextureLoader, Texture as Texture$1, CanvasTarget, Raycaster, OrthographicCamera, PerspectiveCamera, PCFShadowMap, VSMShadowMap, BasicShadowMap, ACESFilmicToneMapping, WebGPURenderer } from 'three/webgpu';
3
+ import { WebGLCubeRenderTarget, WebGLRenderTarget, WebGLRenderer } from 'three';
4
4
  import { Inspector } from 'three/addons/inspector/Inspector.js';
5
5
  import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
6
6
  import * as React from 'react';
@@ -13,7 +13,7 @@ import { HDRLoader } from 'three/examples/jsm/loaders/HDRLoader.js';
13
13
  import { EXRLoader } from 'three/examples/jsm/loaders/EXRLoader.js';
14
14
  import { UltraHDRLoader } from 'three/examples/jsm/loaders/UltraHDRLoader.js';
15
15
  import { GainMapLoader } from '@monogrid/gainmap-js';
16
- import Tb, { unstable_scheduleCallback, unstable_IdlePriority } from 'scheduler';
16
+ import Tb, { unstable_getCurrentPriorityLevel, unstable_IdlePriority, unstable_LowPriority, unstable_NormalPriority, unstable_UserBlockingPriority, unstable_ImmediatePriority, unstable_scheduleCallback } from 'scheduler';
17
17
  import { createWithEqualityFn } from 'zustand/traditional';
18
18
  import { getScheduler } from '@pmndrs/scheduler';
19
19
  export { Scheduler, getScheduler } from '@pmndrs/scheduler';
@@ -36,10 +36,13 @@ const R3F_BUILD_WEBGPU = true;
36
36
 
37
37
  const THREE = /*#__PURE__*/_mergeNamespaces({
38
38
  __proto__: null,
39
+ CubeRenderTarget: CubeRenderTarget,
40
+ CubeRenderTargetCompat: CubeRenderTarget,
39
41
  Inspector: Inspector,
40
42
  R3F_BUILD_LEGACY: R3F_BUILD_LEGACY,
41
43
  R3F_BUILD_WEBGPU: R3F_BUILD_WEBGPU,
42
44
  RenderTargetCompat: RenderTarget,
45
+ WebGLCubeRenderTarget: WebGLCubeRenderTarget,
43
46
  WebGLRenderTarget: WebGLRenderTarget,
44
47
  WebGLRenderer: WebGLRenderer
45
48
  }, [webgpu]);
@@ -313,15 +316,16 @@ function EnvironmentPortal({
313
316
  preset = void 0,
314
317
  extensions
315
318
  }) {
316
- const gl = useThree$1((state) => state.gl);
319
+ const renderer = useThree$1((state) => state.renderer);
320
+ const isLegacy = useThree$1((state) => state.isLegacy);
317
321
  const defaultScene = useThree$1((state) => state.scene);
318
322
  const camera = React.useRef(null);
319
323
  const [virtualScene] = React.useState(() => new Scene());
320
324
  const fbo = React.useMemo(() => {
321
- const fbo2 = new WebGLCubeRenderTarget(resolution);
325
+ const fbo2 = isLegacy ? new WebGLCubeRenderTarget(resolution) : new CubeRenderTarget(resolution);
322
326
  fbo2.texture.type = HalfFloatType;
323
327
  return fbo2;
324
- }, [resolution]);
328
+ }, [resolution, isLegacy]);
325
329
  React.useEffect(() => {
326
330
  return () => {
327
331
  fbo.dispose();
@@ -329,10 +333,10 @@ function EnvironmentPortal({
329
333
  }, [fbo]);
330
334
  React.useLayoutEffect(() => {
331
335
  if (frames === 1) {
332
- const autoClear = gl.autoClear;
333
- gl.autoClear = true;
334
- camera.current.update(gl, virtualScene);
335
- gl.autoClear = autoClear;
336
+ const autoClear = renderer.autoClear;
337
+ renderer.autoClear = true;
338
+ camera.current.update(renderer, virtualScene);
339
+ renderer.autoClear = autoClear;
336
340
  }
337
341
  return setEnvProps(background, scene, defaultScene, fbo.texture, {
338
342
  backgroundBlurriness: blur ?? backgroundBlurriness,
@@ -349,7 +353,7 @@ function EnvironmentPortal({
349
353
  defaultScene,
350
354
  background,
351
355
  frames,
352
- gl,
356
+ renderer,
353
357
  blur,
354
358
  backgroundBlurriness,
355
359
  backgroundIntensity,
@@ -360,10 +364,10 @@ function EnvironmentPortal({
360
364
  let count = 1;
361
365
  useFrame$1(() => {
362
366
  if (frames === Infinity || count < frames) {
363
- const autoClear = gl.autoClear;
364
- gl.autoClear = true;
365
- camera.current.update(gl, virtualScene);
366
- gl.autoClear = autoClear;
367
+ const autoClear = renderer.autoClear;
368
+ renderer.autoClear = true;
369
+ camera.current.update(renderer, virtualScene);
370
+ renderer.autoClear = autoClear;
367
371
  count++;
368
372
  }
369
373
  });
@@ -430,7 +434,6 @@ function Environment(props) {
430
434
  var __defProp = Object.defineProperty;
431
435
  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
432
436
  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
433
- const act = React["act"];
434
437
  const useIsomorphicLayoutEffect = /* @__PURE__ */ (() => typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative"))() ? React.useLayoutEffect : React.useEffect;
435
438
  function useMutableCallback(fn) {
436
439
  const ref = React.useRef(fn);
@@ -606,8 +609,7 @@ function prepare(target, root, type, props) {
606
609
  object,
607
610
  eventCount: 0,
608
611
  handlers: {},
609
- isHidden: false,
610
- deferredRefs: []
612
+ isHidden: false
611
613
  };
612
614
  if (object) object.__r3f = instance;
613
615
  }
@@ -764,6 +766,17 @@ function unregisterVisibility(store, object) {
764
766
  internal.visibilityRegistry.delete(object.uuid);
765
767
  internal.occlusionCache.delete(object);
766
768
  }
769
+ function updateVisibilityHandlers(store, object, handlers) {
770
+ const { internal } = store.getState();
771
+ const entry = internal.visibilityRegistry.get(object.uuid);
772
+ if (!entry) return false;
773
+ entry.handlers = handlers;
774
+ if ((handlers.onOccluded || handlers.onVisible) && !internal.occlusionEnabled) {
775
+ object.occlusionTest = true;
776
+ enableOcclusion(store);
777
+ }
778
+ return true;
779
+ }
767
780
  function checkVisibility(state) {
768
781
  const { internal, camera } = state;
769
782
  const registry = internal.visibilityRegistry;
@@ -924,9 +937,9 @@ function diffProps(instance, newProps) {
924
937
  const { root, key } = resolve(instance.object, prop);
925
938
  if (root.constructor && root.constructor.length === 0) {
926
939
  const ctor = getMemoizedPrototype(root);
927
- if (!is.und(ctor)) changedProps[key] = ctor[key];
940
+ if (!is.und(ctor)) changedProps[prop] = ctor[key];
928
941
  } else {
929
- changedProps[key] = 0;
942
+ changedProps[prop] = 0;
930
943
  }
931
944
  }
932
945
  return changedProps;
@@ -951,10 +964,7 @@ function applyProps(object, props) {
951
964
  continue;
952
965
  }
953
966
  if (value === void 0) continue;
954
- if (isFromRef(value)) {
955
- instance?.deferredRefs?.push({ prop, ref: value[FROM_REF] });
956
- continue;
957
- }
967
+ if (isFromRef(value)) continue;
958
968
  if (isOnce(value)) {
959
969
  if (instance?.appliedOnce?.has(prop)) continue;
960
970
  if (instance) {
@@ -990,6 +1000,19 @@ function applyProps(object, props) {
990
1000
  } else if (isVectorLike(target) && is.num(value)) {
991
1001
  if ("setScalar" in target && typeof target.setScalar === "function") target.setScalar(value);
992
1002
  else target.set(value);
1003
+ } else if (root instanceof ShaderMaterial && key === "uniforms" && is.obj(value)) {
1004
+ if (!is.obj(root.uniforms)) root.uniforms = {};
1005
+ const uniforms = root.uniforms;
1006
+ const nextUniforms = value;
1007
+ for (const name in nextUniforms) {
1008
+ const uniform = nextUniforms[name];
1009
+ const targetUniform = uniforms[name];
1010
+ if (targetUniform) Object.assign(targetUniform, uniform);
1011
+ else {
1012
+ const nextUniform = uniform instanceof Uniform ? uniform.clone() : new Uniform(uniform.value);
1013
+ uniforms[name] = nextUniform;
1014
+ }
1015
+ }
993
1016
  } else {
994
1017
  root[key] = value;
995
1018
  if (key.endsWith("Node") && root.isMaterial) {
@@ -1008,6 +1031,9 @@ function applyProps(object, props) {
1008
1031
  if (instance.eventCount && object2.raycast !== null) {
1009
1032
  rootState.internal.interaction.push(object2);
1010
1033
  }
1034
+ }
1035
+ if (instance?.parent && rootState?.internal && instance.object?.isObject3D) {
1036
+ const object2 = instance.object;
1011
1037
  const root = findInitialRoot(instance);
1012
1038
  const visibilityHandlers = {
1013
1039
  onFramed: instance.handlers.onFramed,
@@ -1015,7 +1041,9 @@ function applyProps(object, props) {
1015
1041
  onVisible: instance.handlers.onVisible
1016
1042
  };
1017
1043
  if (hasVisibilityHandlers(visibilityHandlers)) {
1018
- registerVisibility(root, object2, visibilityHandlers);
1044
+ if (!updateVisibilityHandlers(root, object2, visibilityHandlers)) {
1045
+ registerVisibility(root, object2, visibilityHandlers);
1046
+ }
1019
1047
  } else {
1020
1048
  unregisterVisibility(root, object2);
1021
1049
  }
@@ -1543,6 +1571,7 @@ function createPointerEvents(store) {
1543
1571
  set((state) => ({ events: { ...state.events, connected: void 0 } }));
1544
1572
  }
1545
1573
  },
1574
+ // PREVIEW (A8): the XR pointer registration API may change before stable.
1546
1575
  registerPointer: (config) => {
1547
1576
  const pointerId = nextXRPointerId++;
1548
1577
  xrPointers.set(pointerId, config);
@@ -1630,11 +1659,10 @@ function notifyAlpha({ message, link }) {
1630
1659
  }
1631
1660
 
1632
1661
  const INTERNAL_LIB_MARKERS = ["zustand", "setState", "Object.assign"];
1633
- const INTERNAL_FIBER_MARKERS = ["packages/fiber/src", "packages/fiber/dist", "@react-three/fiber", "@react-three_fiber"];
1634
1662
  function isInternalRendererAccess(stack, callerDepth = 2) {
1635
1663
  if (!stack) return false;
1636
1664
  const caller = stack.split("\n")[callerDepth] ?? "";
1637
- return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m)) || INTERNAL_FIBER_MARKERS.some((m) => caller.includes(m));
1665
+ return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m));
1638
1666
  }
1639
1667
 
1640
1668
  const R3F_CONTEXT = Symbol.for("@react-three/fiber.context");
@@ -1769,6 +1797,7 @@ const createStore = (invalidate, advance) => {
1769
1797
  }),
1770
1798
  setFrameloop: (frameloop = "always") => {
1771
1799
  set(() => ({ frameloop }));
1800
+ getScheduler().frameloop = frameloop;
1772
1801
  },
1773
1802
  setError: (error) => set(() => ({ error })),
1774
1803
  error: null,
@@ -1949,19 +1978,25 @@ function loadingFn(extensions, onProgress) {
1949
1978
  );
1950
1979
  };
1951
1980
  }
1952
- function useLoader(loader, input, extensions, onProgress) {
1953
- const keys = Array.isArray(input) ? input : [input];
1981
+ function useLoader(loader, input, extensions, onProgress, cacheKey) {
1982
+ const inputs = Array.isArray(input) ? input : [input];
1983
+ const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
1954
1984
  const fn = loadingFn(extensions, onProgress);
1955
- const results = keys.map((key) => suspend(fn, [loader, key], { equal: is.equ }));
1985
+ const results = cacheKeys.map(
1986
+ (key, index) => suspend(() => fn(loader, inputs[index]), [loader, key], { equal: is.equ })
1987
+ );
1956
1988
  return Array.isArray(input) ? results : results[0];
1957
1989
  }
1958
- useLoader.preload = function(loader, input, extensions, onProgress) {
1959
- const keys = Array.isArray(input) ? input : [input];
1960
- keys.forEach((key) => preload(loadingFn(extensions, onProgress), [loader, key]));
1990
+ useLoader.preload = function(loader, input, extensions, onProgress, cacheKey) {
1991
+ const inputs = Array.isArray(input) ? input : [input];
1992
+ const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
1993
+ cacheKeys.forEach(
1994
+ (key, index) => preload(() => loadingFn(extensions, onProgress)(loader, inputs[index]), [loader, key])
1995
+ );
1961
1996
  };
1962
- useLoader.clear = function(loader, input) {
1963
- const keys = Array.isArray(input) ? input : [input];
1964
- keys.forEach((key) => clear([loader, key]));
1997
+ useLoader.clear = function(loader, input, cacheKey) {
1998
+ const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
1999
+ cacheKeys.forEach((key) => clear([loader, key]));
1965
2000
  };
1966
2001
  useLoader.loader = getLoader;
1967
2002
 
@@ -2383,7 +2418,7 @@ function advance(timestamp) {
2383
2418
  getScheduler().step(timestamp);
2384
2419
  }
2385
2420
 
2386
- const version = "10.0.0-alpha.2";
2421
+ const version = "10.0.0-alpha.3";
2387
2422
  const packageData = {
2388
2423
  version: version};
2389
2424
 
@@ -13639,7 +13674,7 @@ function n0() {
13639
13674
  var t0 = n0();
13640
13675
  const r0 = Xb(t0);
13641
13676
 
13642
- const t = 1, o = 8, r = 32, e = 2;
13677
+ const t = 1, o = 8, r = 32, e = 2, i$1 = 268435456;
13643
13678
 
13644
13679
  function createReconciler(config) {
13645
13680
  const reconciler2 = r0(config);
@@ -13804,7 +13839,15 @@ function setFiberRef(fiber, publicInstance) {
13804
13839
  }
13805
13840
  }
13806
13841
  const reconstructed = [];
13807
- function swapInstances() {
13842
+ function flushReconstructedInstances() {
13843
+ if (reconstructed.length === 0) return;
13844
+ try {
13845
+ swapReconstructedInstances();
13846
+ } finally {
13847
+ reconstructed.length = 0;
13848
+ }
13849
+ }
13850
+ function swapReconstructedInstances() {
13808
13851
  for (const [instance] of reconstructed) {
13809
13852
  const parent = instance.parent;
13810
13853
  if (parent) {
@@ -13822,6 +13865,7 @@ function swapInstances() {
13822
13865
  }
13823
13866
  }
13824
13867
  if (instance.isHidden) unhideInstance(instance);
13868
+ if (isObject3D(instance.object)) removeInteractivity(findInitialRoot(instance), instance.object);
13825
13869
  if (instance.object.__r3f) delete instance.object.__r3f;
13826
13870
  if (instance.type !== "primitive") disposeOnIdle(instance.object);
13827
13871
  }
@@ -13834,6 +13878,8 @@ function swapInstances() {
13834
13878
  instance.object.__r3f = instance;
13835
13879
  setFiberRef(fiber, instance.object);
13836
13880
  delete instance.appliedOnce;
13881
+ instance.eventCount = 0;
13882
+ instance.handlers = {};
13837
13883
  applyProps(instance.object, instance.props);
13838
13884
  if (instance.props.attach) {
13839
13885
  attach(parent, instance);
@@ -13850,14 +13896,114 @@ function swapInstances() {
13850
13896
  invalidateInstance(instance);
13851
13897
  }
13852
13898
  }
13853
- reconstructed.length = 0;
13854
13899
  }
13855
13900
  const handleTextInstance = () => {
13856
13901
  };
13857
13902
  const NO_CONTEXT = {};
13858
13903
  let currentUpdatePriority = NoEventPriority;
13859
- const NoFlags = 0;
13860
- const Update = 4;
13904
+ function getEventPriority(type) {
13905
+ switch (type) {
13906
+ case "beforetoggle":
13907
+ case "cancel":
13908
+ case "click":
13909
+ case "close":
13910
+ case "contextmenu":
13911
+ case "copy":
13912
+ case "cut":
13913
+ case "auxclick":
13914
+ case "dblclick":
13915
+ case "dragend":
13916
+ case "dragstart":
13917
+ case "drop":
13918
+ case "focusin":
13919
+ case "focusout":
13920
+ case "input":
13921
+ case "invalid":
13922
+ case "keydown":
13923
+ case "keypress":
13924
+ case "keyup":
13925
+ case "mousedown":
13926
+ case "mouseup":
13927
+ case "paste":
13928
+ case "pause":
13929
+ case "play":
13930
+ case "pointercancel":
13931
+ case "pointerdown":
13932
+ case "pointerup":
13933
+ case "ratechange":
13934
+ case "reset":
13935
+ case "resize":
13936
+ case "seeked":
13937
+ case "submit":
13938
+ case "touchcancel":
13939
+ case "touchend":
13940
+ case "touchstart":
13941
+ case "volumechange":
13942
+ case "change":
13943
+ case "selectionchange":
13944
+ case "compositionstart":
13945
+ case "compositionend":
13946
+ case "compositionupdate":
13947
+ case "beforeinput":
13948
+ case "blur":
13949
+ case "fullscreenchange":
13950
+ case "focus":
13951
+ case "hashchange":
13952
+ case "popstate":
13953
+ case "select":
13954
+ case "selectstart":
13955
+ return e;
13956
+ case "drag":
13957
+ case "dragenter":
13958
+ case "dragexit":
13959
+ case "dragleave":
13960
+ case "dragover":
13961
+ case "mousemove":
13962
+ case "mouseout":
13963
+ case "mouseover":
13964
+ case "pointermove":
13965
+ case "pointerout":
13966
+ case "pointerover":
13967
+ case "scroll":
13968
+ case "touchmove":
13969
+ case "wheel":
13970
+ case "mouseenter":
13971
+ case "mouseleave":
13972
+ case "pointerenter":
13973
+ case "pointerleave":
13974
+ return o;
13975
+ case "message": {
13976
+ switch (unstable_getCurrentPriorityLevel()) {
13977
+ case unstable_ImmediatePriority:
13978
+ return e;
13979
+ case unstable_UserBlockingPriority:
13980
+ return o;
13981
+ case unstable_NormalPriority:
13982
+ case unstable_LowPriority:
13983
+ return r;
13984
+ case unstable_IdlePriority:
13985
+ return i$1;
13986
+ default:
13987
+ return r;
13988
+ }
13989
+ }
13990
+ default:
13991
+ return r;
13992
+ }
13993
+ }
13994
+ function scheduleMicrotask(callback) {
13995
+ if (typeof queueMicrotask === "function") {
13996
+ queueMicrotask(callback);
13997
+ } else if (typeof Promise !== "undefined") {
13998
+ Promise.resolve().then(callback).catch((error) => {
13999
+ setTimeout(() => {
14000
+ throw error;
14001
+ });
14002
+ });
14003
+ } else {
14004
+ setTimeout(callback);
14005
+ }
14006
+ }
13861
14007
  const reconciler = /* @__PURE__ */ createReconciler({
13862
14008
  isPrimaryRenderer: false,
13863
14009
  warnsIfNotActing: false,
@@ -13896,16 +14042,15 @@ const reconciler = /* @__PURE__ */ createReconciler({
13896
14042
  else if (newProps.args?.length !== oldProps.args?.length) reconstruct = true;
13897
14043
  else if (newProps.args?.some((value, index) => value !== oldProps.args?.[index])) reconstruct = true;
13898
14044
  if (reconstruct) {
13899
- reconstructed.push([instance, { ...newProps }, fiber]);
14045
+ reconstructed.push([instance, getInstanceProps(newProps), fiber]);
13900
14046
  } else {
13901
14047
  const changedProps = diffProps(instance, newProps);
13902
- if (Object.keys(changedProps).length) {
13903
- Object.assign(instance.props, changedProps);
13904
- applyProps(instance.object, changedProps);
13905
- }
14048
+ const attach2 = instance.props.attach;
14049
+ instance.props = getInstanceProps(newProps);
14050
+ if (attach2 !== void 0) instance.props.attach = attach2;
14051
+ else delete instance.props.attach;
14052
+ if (Object.keys(changedProps).length) applyProps(instance.object, changedProps);
13906
14053
  }
13907
- const isTailSibling = fiber.sibling === null || (fiber.flags & Update) === NoFlags;
13908
- if (isTailSibling) swapInstances();
13909
14054
  },
13910
14055
  finalizeInitialChildren: (instance) => {
13911
14056
  for (const prop in instance.props) {
@@ -13930,8 +14075,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
13930
14075
  const target = container.getState().internal.container ?? container.getState().scene;
13931
14076
  return prepare(target, container, "", {});
13932
14077
  },
13933
- resetAfterCommit: () => {
13934
- },
14078
+ // Reconstructed instances are swapped once all mutations are committed,
14079
+ // before layout effects run so refs point to the new objects
14080
+ resetAfterCommit: flushReconstructedInstances,
13935
14081
  shouldSetTextContent: () => false,
13936
14082
  clearContainer: () => false,
13937
14083
  hideInstance,
@@ -13939,6 +14085,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
13939
14085
  createTextInstance: handleTextInstance,
13940
14086
  hideTextInstance: handleTextInstance,
13941
14087
  unhideTextInstance: handleTextInstance,
14088
+ // Mirrors react-dom, which flushes discrete work in microtasks
14089
+ supportsMicrotasks: true,
14090
+ scheduleMicrotask,
13942
14091
  scheduleTimeout: typeof setTimeout === "function" ? setTimeout : void 0,
13943
14092
  cancelTimeout: typeof clearTimeout === "function" ? clearTimeout : void 0,
13944
14093
  noTimeout: -1,
@@ -13979,28 +14128,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
13979
14128
  },
13980
14129
  resolveUpdatePriority() {
13981
14130
  if (currentUpdatePriority !== NoEventPriority) return currentUpdatePriority;
13982
- switch (typeof window !== "undefined" && window.event?.type) {
13983
- case "click":
13984
- case "contextmenu":
13985
- case "dblclick":
13986
- case "dragenter":
13987
- case "dragleave":
13988
- case "drop":
13989
- case "pointercancel":
13990
- case "pointerdown":
13991
- case "pointerup":
13992
- return e;
13993
- case "dragover":
13994
- case "pointermove":
13995
- case "pointerout":
13996
- case "pointerover":
13997
- case "pointerenter":
13998
- case "pointerleave":
13999
- case "wheel":
14000
- return o;
14001
- default:
14002
- return r;
14003
- }
14131
+ const eventType = typeof window !== "undefined" ? window.event?.type : void 0;
14132
+ if (eventType === void 0) return r;
14133
+ return getEventPriority(eventType);
14004
14134
  },
14005
14135
  resetFormInstance() {
14006
14136
  },
@@ -14049,11 +14179,15 @@ const reconciler = /* @__PURE__ */ createReconciler({
14049
14179
  cloneMutableTextInstance(textInstance) {
14050
14180
  return textInstance;
14051
14181
  },
14182
+ // React 19.2 added these for root-level view transitions. They only run for hosts that opt into
14183
+ // view transitions by returning a container from cloneRootViewTransitionContainer; R3F renders
14184
+ // into a WebGL/WebGPU canvas, where cloning the root has no meaning, so we never opt in and
14185
+ // React never calls them. They stay as no-ops rather than throws: the host config is shared by
14186
+ // every root, and a throw here would turn a React-internal probe into a hard crash for users.
14187
+ // Guarded by a test asserting a full render + unmount never reaches them.
14052
14188
  cloneRootViewTransitionContainer(_rootContainer) {
14053
- throw new Error("Not implemented.");
14054
14189
  },
14055
14190
  removeRootViewTransitionClone(_rootContainer, _clone) {
14056
- throw new Error("Not implemented.");
14057
14191
  },
14058
14192
  // https://github.com/facebook/react/pull/32465
14059
14193
  createFragmentInstance: (_fiber) => null,
@@ -14138,6 +14272,7 @@ function createRoot(canvas) {
14138
14272
  const lastConfiguredProps = {};
14139
14273
  let configured = false;
14140
14274
  let pending = null;
14275
+ let rendererSetup = null;
14141
14276
  return {
14142
14277
  async configure(props = {}) {
14143
14278
  let resolve;
@@ -14168,7 +14303,7 @@ function createRoot(canvas) {
14168
14303
  forceEven
14169
14304
  } = props;
14170
14305
  const textureColorSpace = is.obj(glConfig) && !is.fun(glConfig) && !isRenderer(glConfig) && glConfig.textureColorSpace || is.obj(rendererConfig) && !is.fun(rendererConfig) && !isRenderer(rendererConfig) && rendererConfig.textureColorSpace || SRGBColorSpace;
14171
- const state = store.getState();
14306
+ let state = store.getState();
14172
14307
  const defaultGLProps = {
14173
14308
  canvas,
14174
14309
  powerPreference: "high-performance",
@@ -14196,56 +14331,68 @@ function createRoot(canvas) {
14196
14331
  "The `primaryCanvas` prop for multi-canvas rendering cannot be used with WebGL. Remove the `gl` prop or use WebGPU."
14197
14332
  );
14198
14333
  }
14199
- if (wantsGL && !state.internal.actualRenderer) {
14200
- renderer = await resolveRenderer(glConfig, defaultGLProps, WebGLRenderer);
14201
- state.internal.actualRenderer = renderer;
14202
- state.set({ isLegacy: true, gl: renderer, renderer, primaryStore: store });
14203
- } else if (!wantsGL && primaryCanvas && !state.internal.actualRenderer) {
14204
- const primary = await waitForPrimary(primaryCanvas);
14205
- renderer = primary.renderer;
14206
- state.internal.actualRenderer = renderer;
14207
- const canvasTarget = new CanvasTarget(canvas);
14208
- primary.store.setState((prev) => ({
14209
- internal: { ...prev.internal, isMultiCanvas: true }
14210
- }));
14211
- state.set((prev) => ({
14212
- webGPUSupported: primary.store.getState().webGPUSupported,
14213
- renderer,
14214
- primaryStore: primary.store,
14215
- internal: {
14216
- ...prev.internal,
14217
- canvasTarget,
14218
- isMultiCanvas: true,
14219
- isSecondary: true,
14220
- targetId: primaryCanvas
14221
- }
14222
- }));
14223
- } else if (!wantsGL && !state.internal.actualRenderer) {
14224
- renderer = await resolveRenderer(rendererConfig, defaultGPUProps, WebGPURenderer);
14225
- if (!renderer.hasInitialized?.()) {
14226
- const size2 = computeInitialSize(canvas, propsSize);
14227
- if (size2.width > 0 && size2.height > 0) {
14228
- const pixelRatio = calculateDpr(dpr);
14229
- canvas.width = size2.width * pixelRatio;
14230
- canvas.height = size2.height * pixelRatio;
14231
- }
14232
- await renderer.init();
14233
- }
14234
- const backend = renderer.backend;
14235
- const isWebGPUBackend = backend && "isWebGPUBackend" in backend;
14236
- state.internal.actualRenderer = renderer;
14237
- state.set({ webGPUSupported: isWebGPUBackend, renderer, primaryStore: store });
14238
- if (canvasId && !state.internal.isSecondary) {
14239
- const canvasTarget = new CanvasTarget(canvas);
14240
- const unregisterPrimary = registerPrimary(canvasId, renderer, store);
14241
- state.set((prev) => ({
14242
- internal: {
14243
- ...prev.internal,
14244
- canvasTarget,
14245
- unregisterPrimary
14334
+ if (!state.internal.actualRenderer) {
14335
+ if (!rendererSetup) {
14336
+ rendererSetup = (async () => {
14337
+ if (wantsGL) {
14338
+ renderer = await resolveRenderer(glConfig, defaultGLProps, WebGLRenderer);
14339
+ state.internal.actualRenderer = renderer;
14340
+ state.set({ isLegacy: true, gl: renderer, renderer, primaryStore: store });
14341
+ } else if (!wantsGL && primaryCanvas) {
14342
+ const primary = await waitForPrimary(primaryCanvas);
14343
+ renderer = primary.renderer;
14344
+ state.internal.actualRenderer = renderer;
14345
+ const canvasTarget = new CanvasTarget(canvas);
14346
+ primary.store.setState((prev) => ({
14347
+ internal: { ...prev.internal, isMultiCanvas: true }
14348
+ }));
14349
+ state.set((prev) => ({
14350
+ webGPUSupported: primary.store.getState().webGPUSupported,
14351
+ renderer,
14352
+ primaryStore: primary.store,
14353
+ internal: {
14354
+ ...prev.internal,
14355
+ canvasTarget,
14356
+ isMultiCanvas: true,
14357
+ isSecondary: true,
14358
+ targetId: primaryCanvas
14359
+ }
14360
+ }));
14361
+ } else if (!wantsGL) {
14362
+ renderer = await resolveRenderer(rendererConfig, defaultGPUProps, WebGPURenderer);
14363
+ if (!renderer.hasInitialized?.()) {
14364
+ const size2 = computeInitialSize(canvas, propsSize);
14365
+ if (size2.width > 0 && size2.height > 0) {
14366
+ const pixelRatio = calculateDpr(dpr);
14367
+ canvas.width = size2.width * pixelRatio;
14368
+ canvas.height = size2.height * pixelRatio;
14369
+ }
14370
+ await renderer.init();
14371
+ }
14372
+ const backend = renderer.backend;
14373
+ const isWebGPUBackend = backend && "isWebGPUBackend" in backend;
14374
+ state.internal.actualRenderer = renderer;
14375
+ state.set({ webGPUSupported: isWebGPUBackend, renderer, primaryStore: store });
14376
+ if (canvasId && !state.internal.isSecondary) {
14377
+ const canvasTarget = new CanvasTarget(canvas);
14378
+ const unregisterPrimary = registerPrimary(canvasId, renderer, store);
14379
+ state.set((prev) => ({
14380
+ internal: {
14381
+ ...prev.internal,
14382
+ canvasTarget,
14383
+ unregisterPrimary
14384
+ }
14385
+ }));
14386
+ }
14246
14387
  }
14247
- }));
14388
+ })().catch((err) => {
14389
+ rendererSetup = null;
14390
+ throw err;
14391
+ });
14248
14392
  }
14393
+ await rendererSetup;
14394
+ state = store.getState();
14395
+ renderer = state.internal.actualRenderer;
14249
14396
  }
14250
14397
  let raycaster = state.raycaster;
14251
14398
  if (!raycaster) state.set({ raycaster: raycaster = new Raycaster() });
@@ -14595,7 +14742,8 @@ function unmountComponentAtNode(canvas, callback) {
14595
14742
  dispose(state.scene);
14596
14743
  _roots.delete(canvas);
14597
14744
  if (callback) callback(canvas);
14598
- } catch {
14745
+ } catch (error) {
14746
+ console.warn("[R3F] Error while unmounting root; teardown may be incomplete:", error);
14599
14747
  }
14600
14748
  }, 500);
14601
14749
  }
@@ -14658,6 +14806,7 @@ function PortalInner({ state = {}, children, container }) {
14658
14806
  viewport = rootState.viewport.getCurrentViewport(camera, new Vector3(), resolvedSize);
14659
14807
  if (camera !== rootState.camera) updateCamera(camera, resolvedSize);
14660
14808
  }
14809
+ const set = injectState.set;
14661
14810
  return {
14662
14811
  // The intersect consists of the previous root state
14663
14812
  ...rootState,
@@ -14676,7 +14825,7 @@ function PortalInner({ state = {}, children, container }) {
14676
14825
  size: resolvedSize,
14677
14826
  viewport: { ...rootState.viewport, ...viewport },
14678
14827
  // Layers are allowed to override events
14679
- setEvents: (events2) => injectState.set((state2) => ({ ...state2, events: { ...state2.events, ...events2 } })),
14828
+ setEvents: (events2) => set((state2) => ({ ...state2, events: { ...state2.events, ...events2 } })),
14680
14829
  // Container for child attachment - the portalScene (injected or container itself)
14681
14830
  internal: { ...rootState.internal, ...injectState.internal, container: portalScene }
14682
14831
  };
@@ -14748,14 +14897,36 @@ function parseRendererConfig(rendererProp) {
14748
14897
  return { primaryCanvas: void 0, scheduler: void 0, renderer: rendererProp };
14749
14898
  }
14750
14899
 
14900
+ const RESOURCE_KINDS = ["nodes", "uniforms", "buffers", "gpuStorage"];
14901
+ const registries = /* @__PURE__ */ new WeakMap();
14902
+ function getKindRegistry(store, kind) {
14903
+ let registry = registries.get(store);
14904
+ if (!registry) {
14905
+ registry = {
14906
+ nodes: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
14907
+ uniforms: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
14908
+ buffers: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
14909
+ gpuStorage: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() }
14910
+ };
14911
+ registries.set(store, registry);
14912
+ }
14913
+ return registry[kind];
14914
+ }
14915
+ function invalidateResource(store, kind, scopeKey) {
14916
+ const registry = getKindRegistry(store, kind);
14917
+ {
14918
+ registry.valid.clear();
14919
+ registry.staged.clear();
14920
+ }
14921
+ }
14922
+ function invalidateAllResources(store) {
14923
+ for (const kind of RESOURCE_KINDS) invalidateResource(store, kind);
14924
+ }
14925
+
14751
14926
  function clearHmrCaches(store) {
14752
- store.setState((state) => ({
14753
- nodes: {},
14754
- uniforms: {},
14755
- buffers: {},
14756
- gpuStorage: {},
14757
- _hmrVersion: state._hmrVersion + 1
14758
- }));
14927
+ const primary = store.getState().primaryStore ?? store;
14928
+ invalidateAllResources(primary);
14929
+ primary.setState((state) => ({ _hmrVersion: state._hmrVersion + 1 }));
14759
14930
  }
14760
14931
 
14761
14932
  function CanvasImpl({
@@ -14836,6 +15007,7 @@ function CanvasImpl({
14836
15007
  const handleDropMissed = useMutableCallback(onDropMissed);
14837
15008
  const [block, setBlock] = React.useState(false);
14838
15009
  const [error, setError] = React.useState(false);
15010
+ const [fallbackVisible, setFallbackVisible] = React.useState(false);
14839
15011
  if (block) throw block;
14840
15012
  if (error) throw error;
14841
15013
  const root = React.useRef(null);
@@ -14843,6 +15015,7 @@ function CanvasImpl({
14843
15015
  const unsubscribeErrorRef = React.useRef(null);
14844
15016
  useIsomorphicLayoutEffect(() => {
14845
15017
  effectActiveRef.current = true;
15018
+ if (fallbackVisible) return;
14846
15019
  const canvas = canvasRef.current;
14847
15020
  if (effectiveSize.width > 0 && effectiveSize.height > 0 && canvas) {
14848
15021
  if (!root.current) {
@@ -14863,7 +15036,7 @@ function CanvasImpl({
14863
15036
  }
14864
15037
  async function run() {
14865
15038
  if (!effectActiveRef.current || !root.current) return;
14866
- await root.current.configure({
15039
+ const configured = await root.current.configure({
14867
15040
  id,
14868
15041
  primaryCanvas,
14869
15042
  scheduler,
@@ -14904,8 +15077,20 @@ function CanvasImpl({
14904
15077
  }
14905
15078
  onCreated?.(state);
14906
15079
  }
14907
- });
14908
- if (!effectActiveRef.current || !root.current) return;
15080
+ }).then(
15081
+ () => true,
15082
+ // Renderer setup failed (e.g. no WebGL/WebGPU support). The `fallback` prop lives
15083
+ // inside <canvas>, which browsers don't display, so surface it as visible DOM
15084
+ // instead; with no fallback, rethrow to an external error boundary. (#3757)
15085
+ (setupError) => {
15086
+ if (effectActiveRef.current) {
15087
+ if (fallback != null) setFallbackVisible(true);
15088
+ else setError(setupError);
15089
+ }
15090
+ return false;
15091
+ }
15092
+ );
15093
+ if (!configured || !effectActiveRef.current || !root.current) return;
14909
15094
  root.current.render(
14910
15095
  /* @__PURE__ */ jsx(Bridge, { children: /* @__PURE__ */ jsx(ErrorBoundary, { set: setError, children: /* @__PURE__ */ jsxs(React.Suspense, { fallback: /* @__PURE__ */ jsx(Block, { set: setBlock }), children: [
14911
15096
  backgroundProps && /* @__PURE__ */ jsx(Environment, { ...backgroundProps }),
@@ -14968,7 +15153,11 @@ function CanvasImpl({
14968
15153
  ...style
14969
15154
  },
14970
15155
  ...props,
14971
- children: /* @__PURE__ */ jsx("div", { ref: containerRef, className: "r3f-canvas-container", style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ jsx(
15156
+ children: fallbackVisible ? (
15157
+ // Renderer setup failed: render the fallback as visible DOM. Inside <canvas> (below)
15158
+ // it exists in the tree but browsers never paint it, which is the whole bug (#3757).
15159
+ fallback
15160
+ ) : /* @__PURE__ */ jsx("div", { ref: containerRef, className: "r3f-canvas-container", style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ jsx(
14972
15161
  "canvas",
14973
15162
  {
14974
15163
  ref: canvasRef,
@@ -14987,4 +15176,4 @@ function Canvas(props) {
14987
15176
 
14988
15177
  extend(THREE);
14989
15178
 
14990
- export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, Texture, _roots, act, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, removeInteractivity, resolve, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };
15179
+ export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, Texture, _roots, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, removeInteractivity, resolve, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };