@react-three/fiber 10.0.0-canary.0706a92 → 10.0.0-canary.0f7fc9b

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,22 +1,20 @@
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, 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 { WebGLRenderTarget, WebGLRenderer } from 'three';
4
- import { Inspector } from 'three/addons/inspector/Inspector.js';
2
+ import { CubeRenderTarget, RenderTarget, Frustum, Matrix4, Group, BoxGeometry, MeshBasicNodeMaterial, Mesh, Node, NodeUpdateType, Layers, ShaderMaterial, Uniform, SRGBColorSpace, RGBAFormat, UnsignedByteType, Vector3, Vector2, TextureLoader, Texture as Texture$1, CubeReflectionMapping, EquirectangularReflectionMapping, CubeTextureLoader, CanvasTarget, Raycaster, OrthographicCamera, PerspectiveCamera, Scene, PCFShadowMap, VSMShadowMap, BasicShadowMap, ACESFilmicToneMapping, WebGPURenderer, HalfFloatType, Color } from 'three/webgpu';
3
+ import { WebGLCubeRenderTarget, WebGLRenderTarget, WebGLRenderer } from 'three';
5
4
  import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
6
5
  import * as React from 'react';
7
- import React__default, { useLayoutEffect, useRef, useMemo, useEffect, useContext, useImperativeHandle, useCallback, useState } from 'react';
6
+ import React__default, { useRef, useMemo, useLayoutEffect, useEffect, useContext, useImperativeHandle, useCallback, useState } from 'react';
8
7
  import useMeasure from 'react-use-measure';
9
8
  import { useFiber, useContextBridge, traverseFiber, FiberProvider } from 'its-fine';
10
- import { useThree as useThree$1, useLoader as useLoader$1, useFrame as useFrame$1, createPortal as createPortal$1, applyProps as applyProps$1, extend as extend$1 } from '@react-three/fiber';
9
+ import { createWithEqualityFn } from 'zustand/traditional';
10
+ import { getScheduler } from '@pmndrs/scheduler';
11
+ export { Scheduler, getScheduler } from '@pmndrs/scheduler';
12
+ import Tb, { unstable_getCurrentPriorityLevel, unstable_IdlePriority, unstable_LowPriority, unstable_NormalPriority, unstable_UserBlockingPriority, unstable_ImmediatePriority, unstable_scheduleCallback } from 'scheduler';
11
13
  import { GroundedSkybox } from 'three/examples/jsm/objects/GroundedSkybox.js';
12
14
  import { HDRLoader } from 'three/examples/jsm/loaders/HDRLoader.js';
13
15
  import { EXRLoader } from 'three/examples/jsm/loaders/EXRLoader.js';
14
16
  import { UltraHDRLoader } from 'three/examples/jsm/loaders/UltraHDRLoader.js';
15
17
  import { GainMapLoader } from '@monogrid/gainmap-js';
16
- import Tb, { unstable_scheduleCallback, unstable_IdlePriority } from 'scheduler';
17
- import { createWithEqualityFn } from 'zustand/traditional';
18
- import { getScheduler } from '@pmndrs/scheduler';
19
- export { Scheduler, getScheduler } from '@pmndrs/scheduler';
20
18
  import { suspend, preload, clear } from 'suspend-react';
21
19
 
22
20
  function _mergeNamespaces(n, m) {
@@ -33,15 +31,22 @@ function _mergeNamespaces(n, m) {
33
31
 
34
32
  const R3F_BUILD_LEGACY = true;
35
33
  const R3F_BUILD_WEBGPU = true;
34
+ async function loadInspector() {
35
+ const { Inspector } = await import('three/addons/inspector/Inspector.js');
36
+ return Inspector;
37
+ }
36
38
 
37
39
  const THREE = /*#__PURE__*/_mergeNamespaces({
38
40
  __proto__: null,
39
- Inspector: Inspector,
41
+ CubeRenderTarget: CubeRenderTarget,
42
+ CubeRenderTargetCompat: CubeRenderTarget,
40
43
  R3F_BUILD_LEGACY: R3F_BUILD_LEGACY,
41
44
  R3F_BUILD_WEBGPU: R3F_BUILD_WEBGPU,
42
45
  RenderTargetCompat: RenderTarget,
46
+ WebGLCubeRenderTarget: WebGLCubeRenderTarget,
43
47
  WebGLRenderTarget: WebGLRenderTarget,
44
- WebGLRenderer: WebGLRenderer
48
+ WebGLRenderer: WebGLRenderer,
49
+ loadInspector: loadInspector
45
50
  }, [webgpu]);
46
51
 
47
52
  const primaryRegistry = /* @__PURE__ */ new Map();
@@ -102,549 +107,223 @@ function getPrimaryIds() {
102
107
  return Array.from(primaryRegistry.keys());
103
108
  }
104
109
 
105
- const presetsObj = {
106
- apartment: "lebombo_1k.hdr",
107
- city: "potsdamer_platz_1k.hdr",
108
- dawn: "kiara_1_dawn_1k.hdr",
109
- forest: "forest_slope_1k.hdr",
110
- lobby: "st_fagans_interior_1k.hdr",
111
- night: "dikhololo_night_1k.hdr",
112
- park: "rooitou_park_1k.hdr",
113
- studio: "studio_small_03_1k.hdr",
114
- sunset: "venice_sunset_1k.hdr",
115
- warehouse: "empty_warehouse_01_1k.hdr"
116
- };
110
+ var __defProp = Object.defineProperty;
111
+ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
112
+ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
113
+ const useIsomorphicLayoutEffect = /* @__PURE__ */ (() => typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative"))() ? React.useLayoutEffect : React.useEffect;
114
+ function useMutableCallback(fn) {
115
+ const ref = React.useRef(fn);
116
+ useIsomorphicLayoutEffect(() => void (ref.current = fn), [fn]);
117
+ return ref;
118
+ }
119
+ function useBridge() {
120
+ const fiber = useFiber();
121
+ const ContextBridge = useContextBridge();
122
+ return React.useMemo(
123
+ () => ({ children }) => {
124
+ const strict = !!traverseFiber(fiber, true, (node) => node.type === React.StrictMode);
125
+ const Root = strict ? React.StrictMode : React.Fragment;
126
+ return /* @__PURE__ */ jsx(Root, { children: /* @__PURE__ */ jsx(ContextBridge, { children }) });
127
+ },
128
+ [fiber, ContextBridge]
129
+ );
130
+ }
131
+ function Block({ set }) {
132
+ useIsomorphicLayoutEffect(() => {
133
+ set(new Promise(() => null));
134
+ return () => set(false);
135
+ }, [set]);
136
+ return null;
137
+ }
138
+ const ErrorBoundary = /* @__PURE__ */ (() => {
139
+ var _a;
140
+ return _a = class extends React.Component {
141
+ constructor() {
142
+ super(...arguments);
143
+ __publicField(this, "state", { error: false });
144
+ }
145
+ componentDidCatch(err) {
146
+ this.props.set(err);
147
+ }
148
+ render() {
149
+ return this.state.error ? null : this.props.children;
150
+ }
151
+ }, __publicField(_a, "getDerivedStateFromError", () => ({ error: true })), _a;
152
+ })();
117
153
 
118
- const CUBEMAP_ROOT = "https://raw.githack.com/pmndrs/drei-assets/456060a26bbeb8fdf79326f224b6d99b8bcce736/hdri/";
119
- const isArray = (arr) => Array.isArray(arr);
120
- const defaultFiles = ["/px.png", "/nx.png", "/py.png", "/ny.png", "/pz.png", "/nz.png"];
121
- function useEnvironment({
122
- files = defaultFiles,
123
- path = "",
124
- preset = void 0,
125
- colorSpace = void 0,
126
- extensions
127
- } = {}) {
128
- if (preset) {
129
- validatePreset(preset);
130
- files = presetsObj[preset];
131
- path = CUBEMAP_ROOT;
132
- }
133
- const multiFile = isArray(files);
134
- const { extension, isCubemap } = getExtension(files);
135
- const loader = getLoader$1(extension);
136
- if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
137
- const renderer = useThree$1((state) => state.renderer);
138
- useLayoutEffect(() => {
139
- if (extension !== "webp" && extension !== "jpg" && extension !== "jpeg") return;
140
- function clearGainmapTexture() {
141
- useLoader$1.clear(loader, multiFile ? [files] : files);
154
+ const is = {
155
+ obj: (a) => a === Object(a) && !is.arr(a) && typeof a !== "function",
156
+ fun: (a) => typeof a === "function",
157
+ str: (a) => typeof a === "string",
158
+ num: (a) => typeof a === "number",
159
+ boo: (a) => typeof a === "boolean",
160
+ und: (a) => a === void 0,
161
+ nul: (a) => a === null,
162
+ arr: (a) => Array.isArray(a),
163
+ equ(a, b, { arrays = "shallow", objects = "reference", strict = true } = {}) {
164
+ if (typeof a !== typeof b || !!a !== !!b) return false;
165
+ if (is.str(a) || is.num(a) || is.boo(a)) return a === b;
166
+ const isObj = is.obj(a);
167
+ if (isObj && objects === "reference") return a === b;
168
+ const isArr = is.arr(a);
169
+ if (isArr && arrays === "reference") return a === b;
170
+ if ((isArr || isObj) && a === b) return true;
171
+ let i;
172
+ for (i in a) if (!(i in b)) return false;
173
+ if (isObj && arrays === "shallow" && objects === "shallow") {
174
+ for (i in strict ? b : a) if (!is.equ(a[i], b[i], { strict, objects: "reference" })) return false;
175
+ } else {
176
+ for (i in strict ? b : a) if (a[i] !== b[i]) return false;
142
177
  }
143
- renderer.domElement.addEventListener("webglcontextlost", clearGainmapTexture, { once: true });
144
- }, [extension, files, loader, multiFile, renderer.domElement]);
145
- const loaderResult = useLoader$1(
146
- loader,
147
- multiFile ? [files] : files,
148
- (loader2) => {
149
- if (extension === "webp" || extension === "jpg" || extension === "jpeg") {
150
- loader2.setRenderer?.(renderer);
151
- }
152
- loader2.setPath?.(path);
153
- if (extensions) extensions(loader2);
178
+ if (is.und(i)) {
179
+ if (isArr && a.length === 0 && b.length === 0) return true;
180
+ if (isObj && Object.keys(a).length === 0 && Object.keys(b).length === 0) return true;
181
+ if (a !== b) return false;
154
182
  }
155
- );
156
- let texture = multiFile ? (
157
- // @ts-ignore
158
- loaderResult[0]
159
- ) : loaderResult;
160
- if (extension === "jpg" || extension === "jpeg" || extension === "webp") {
161
- texture = texture.renderTarget?.texture;
162
- }
163
- texture.mapping = isCubemap ? CubeReflectionMapping : EquirectangularReflectionMapping;
164
- texture.colorSpace = colorSpace ?? (isCubemap ? "srgb" : "srgb-linear");
165
- return texture;
166
- }
167
- const preloadDefaultOptions = {
168
- files: defaultFiles,
169
- path: "",
170
- preset: void 0,
171
- extensions: void 0
172
- };
173
- useEnvironment.preload = (preloadOptions) => {
174
- const options = { ...preloadDefaultOptions, ...preloadOptions };
175
- let { files, path = "" } = options;
176
- const { preset, extensions } = options;
177
- if (preset) {
178
- validatePreset(preset);
179
- files = presetsObj[preset];
180
- path = CUBEMAP_ROOT;
181
- }
182
- const { extension } = getExtension(files);
183
- if (extension === "webp" || extension === "jpg" || extension === "jpeg") {
184
- throw new Error("useEnvironment: Preloading gainmaps is not supported");
185
- }
186
- const loader = getLoader$1(extension);
187
- if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
188
- useLoader$1.preload(loader, isArray(files) ? [files] : files, (loader2) => {
189
- loader2.setPath?.(path);
190
- if (extensions) extensions(loader2);
191
- });
192
- };
193
- const clearDefaultOptins = {
194
- files: defaultFiles,
195
- preset: void 0
196
- };
197
- useEnvironment.clear = (clearOptions) => {
198
- const options = { ...clearDefaultOptins, ...clearOptions };
199
- let { files } = options;
200
- const { preset } = options;
201
- if (preset) {
202
- validatePreset(preset);
203
- files = presetsObj[preset];
183
+ return true;
204
184
  }
205
- const { extension } = getExtension(files);
206
- const loader = getLoader$1(extension);
207
- if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
208
- useLoader$1.clear(loader, isArray(files) ? [files] : files);
209
185
  };
210
- function validatePreset(preset) {
211
- if (!(preset in presetsObj)) throw new Error("Preset must be one of: " + Object.keys(presetsObj).join(", "));
186
+ const isOrthographicCamera = (def) => def && def.isOrthographicCamera;
187
+ const isRef$1 = (obj) => obj !== null && typeof obj === "object" && obj.hasOwnProperty("current");
188
+ const isColorRepresentation = (value) => value != null && (typeof value === "string" || typeof value === "number" || value.isColor);
189
+ const isObject3D = (object) => object?.isObject3D;
190
+ const isTexture = (value) => !!value?.isTexture;
191
+ const isVectorLike = (object) => object !== null && typeof object === "object" && "set" in object && typeof object.set === "function";
192
+ const isCopyable = (object) => isVectorLike(object) && "copy" in object && typeof object.copy === "function";
193
+ const hasConstructor = (object) => !!object?.constructor;
194
+
195
+ function calculateDpr(dpr) {
196
+ const target = typeof window !== "undefined" ? window.devicePixelRatio ?? 2 : 1;
197
+ return Array.isArray(dpr) ? Math.min(Math.max(dpr[0], target), dpr[1]) : dpr;
212
198
  }
213
- function getExtension(files) {
214
- const isCubemap = isArray(files) && files.length === 6;
215
- const isGainmap = isArray(files) && files.length === 3 && files.some((file) => file.endsWith("json"));
216
- const firstEntry = isArray(files) ? files[0] : files;
217
- const extension = isCubemap ? "cube" : isGainmap ? "webp" : firstEntry.startsWith("data:application/exr") ? "exr" : firstEntry.startsWith("data:application/hdr") ? "hdr" : firstEntry.startsWith("data:image/jpeg") ? "jpg" : firstEntry.split(".").pop()?.split("?")?.shift()?.toLowerCase();
218
- return { extension, isCubemap, isGainmap };
199
+ function getUuidPrefix(uuid) {
200
+ return uuid.split("-")[0];
219
201
  }
220
- function getLoader$1(extension) {
221
- const loader = extension === "cube" ? CubeTextureLoader : extension === "hdr" ? HDRLoader : extension === "exr" ? EXRLoader : extension === "jpg" || extension === "jpeg" ? UltraHDRLoader : extension === "webp" ? GainMapLoader : null;
222
- return loader;
202
+ function updateCamera(camera, size) {
203
+ if (camera.manual) return;
204
+ if (isOrthographicCamera(camera)) {
205
+ camera.left = size.width / -2;
206
+ camera.right = size.width / 2;
207
+ camera.top = size.height / 2;
208
+ camera.bottom = size.height / -2;
209
+ } else {
210
+ camera.aspect = size.width / size.height;
211
+ }
212
+ camera.updateProjectionMatrix();
223
213
  }
224
-
225
- const isRef$1 = (obj) => obj.current && obj.current.isScene;
226
- const resolveScene = (scene) => isRef$1(scene) ? scene.current : scene;
227
- function setEnvProps(background, scene, defaultScene, texture, sceneProps = {}) {
228
- sceneProps = {
229
- backgroundBlurriness: 0,
230
- backgroundIntensity: 1,
231
- backgroundRotation: [0, 0, 0],
232
- environmentIntensity: 1,
233
- environmentRotation: [0, 0, 0],
234
- ...sceneProps
235
- };
236
- const target = resolveScene(scene || defaultScene);
237
- const oldbg = target.background;
238
- const oldenv = target.environment;
239
- const oldSceneProps = {
240
- // @ts-ignore
241
- backgroundBlurriness: target.backgroundBlurriness,
242
- // @ts-ignore
243
- backgroundIntensity: target.backgroundIntensity,
244
- // @ts-ignore
245
- backgroundRotation: target.backgroundRotation?.clone?.() ?? [0, 0, 0],
246
- // @ts-ignore
247
- environmentIntensity: target.environmentIntensity,
248
- // @ts-ignore
249
- environmentRotation: target.environmentRotation?.clone?.() ?? [0, 0, 0]
250
- };
251
- if (background !== "only") target.environment = texture;
252
- if (background) target.background = texture;
253
- applyProps$1(target, sceneProps);
254
- return () => {
255
- if (background !== "only") target.environment = oldenv;
256
- if (background) target.background = oldbg;
257
- applyProps$1(target, oldSceneProps);
258
- };
214
+ const frustumMatrix = new Matrix4();
215
+ function updateFrustum(camera, frustum) {
216
+ const target = frustum ?? new Frustum();
217
+ frustumMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
218
+ target.setFromProjectionMatrix(frustumMatrix);
219
+ return target;
259
220
  }
260
- function EnvironmentMap({ scene, background = false, map, ...config }) {
261
- const defaultScene = useThree$1((state) => state.scene);
262
- React.useLayoutEffect(() => {
263
- if (map) return setEnvProps(background, scene, defaultScene, map, config);
264
- });
265
- return null;
221
+
222
+ const REACT_INTERNAL_PROPS = ["children", "key", "ref"];
223
+ function findInitialRoot(instance) {
224
+ let root = instance.root;
225
+ while (root.getState().previousRoot) root = root.getState().previousRoot;
226
+ return root;
266
227
  }
267
- function EnvironmentCube({
268
- background = false,
269
- scene,
270
- blur,
271
- backgroundBlurriness,
272
- backgroundIntensity,
273
- backgroundRotation,
274
- environmentIntensity,
275
- environmentRotation,
276
- ...rest
277
- }) {
278
- const texture = useEnvironment(rest);
279
- const defaultScene = useThree$1((state) => state.scene);
280
- React.useLayoutEffect(() => {
281
- return setEnvProps(background, scene, defaultScene, texture, {
282
- backgroundBlurriness: blur ?? backgroundBlurriness,
283
- backgroundIntensity,
284
- backgroundRotation,
285
- environmentIntensity,
286
- environmentRotation
228
+ function getRootState(obj) {
229
+ let state = obj.__r3f?.root.getState();
230
+ if (!state) {
231
+ obj.traverseAncestors((ancestor) => {
232
+ const parentState = ancestor.__r3f?.root.getState();
233
+ if (parentState) {
234
+ state = parentState;
235
+ return false;
236
+ }
287
237
  });
288
- });
289
- React.useEffect(() => {
290
- return () => {
291
- texture.dispose();
292
- };
293
- }, [texture]);
294
- return null;
238
+ }
239
+ return state;
295
240
  }
296
- function EnvironmentPortal({
297
- children,
298
- near = 0.1,
299
- far = 1e3,
300
- resolution = 256,
301
- frames = 1,
302
- map,
303
- background = false,
304
- blur,
305
- backgroundBlurriness,
306
- backgroundIntensity,
307
- backgroundRotation,
308
- environmentIntensity,
309
- environmentRotation,
310
- scene,
311
- files,
312
- path,
313
- preset = void 0,
314
- extensions
315
- }) {
316
- const gl = useThree$1((state) => state.gl);
317
- const defaultScene = useThree$1((state) => state.scene);
318
- const camera = React.useRef(null);
319
- const [virtualScene] = React.useState(() => new Scene());
320
- const fbo = React.useMemo(() => {
321
- const fbo2 = new WebGLCubeRenderTarget(resolution);
322
- fbo2.texture.type = HalfFloatType;
323
- return fbo2;
324
- }, [resolution]);
325
- React.useEffect(() => {
326
- return () => {
327
- fbo.dispose();
328
- };
329
- }, [fbo]);
330
- React.useLayoutEffect(() => {
331
- if (frames === 1) {
332
- const autoClear = gl.autoClear;
333
- gl.autoClear = true;
334
- camera.current.update(gl, virtualScene);
335
- gl.autoClear = autoClear;
336
- }
337
- return setEnvProps(background, scene, defaultScene, fbo.texture, {
338
- backgroundBlurriness: blur ?? backgroundBlurriness,
339
- backgroundIntensity,
340
- backgroundRotation,
341
- environmentIntensity,
342
- environmentRotation
241
+ function buildGraph(object) {
242
+ const data = { nodes: {}, materials: {}, meshes: {} };
243
+ if (object) {
244
+ object.traverse((obj) => {
245
+ if (obj.name) data.nodes[obj.name] = obj;
246
+ if (obj.material) {
247
+ const material = Array.isArray(obj.material) ? obj.material[0] : obj.material;
248
+ const nameAlreadyUsed = data.materials[material.name];
249
+ let materialName = material.name;
250
+ if (nameAlreadyUsed) {
251
+ materialName = materialName + `-${getUuidPrefix(material.uuid)}`;
252
+ material.userData.materialCacheName = materialName;
253
+ }
254
+ data.materials[materialName] = material;
255
+ }
256
+ if (obj.isMesh && !data.meshes[obj.name]) data.meshes[obj.name] = obj;
343
257
  });
344
- }, [
345
- children,
346
- virtualScene,
347
- fbo.texture,
348
- scene,
349
- defaultScene,
350
- background,
351
- frames,
352
- gl,
353
- blur,
354
- backgroundBlurriness,
355
- backgroundIntensity,
356
- backgroundRotation,
357
- environmentIntensity,
358
- environmentRotation
359
- ]);
360
- let count = 1;
361
- useFrame$1(() => {
362
- 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
- count++;
368
- }
369
- });
370
- return /* @__PURE__ */ jsx(Fragment, { children: createPortal$1(
371
- /* @__PURE__ */ jsxs(Fragment, { children: [
372
- children,
373
- /* @__PURE__ */ jsx("cubeCamera", { ref: camera, args: [near, far, fbo] }),
374
- files || preset ? /* @__PURE__ */ jsx(EnvironmentCube, { background: true, files, preset, path, extensions }) : map ? /* @__PURE__ */ jsx(EnvironmentMap, { background: true, map, extensions }) : null
375
- ] }),
376
- virtualScene
377
- ) });
378
- }
379
- function EnvironmentGround(props) {
380
- const textureDefault = useEnvironment(props);
381
- const texture = props.map || textureDefault;
382
- React.useMemo(() => extend$1({ GroundProjectedEnvImpl: GroundedSkybox }), []);
383
- React.useEffect(() => {
384
- return () => {
385
- textureDefault.dispose();
386
- };
387
- }, [textureDefault]);
388
- const height = props.ground?.height ?? 15;
389
- const radius = props.ground?.radius ?? 60;
390
- const scale = props.ground?.scale ?? 1e3;
391
- const args = React.useMemo(
392
- () => [texture, height, radius],
393
- [texture, height, radius]
394
- );
395
- return /* @__PURE__ */ jsxs(Fragment, { children: [
396
- /* @__PURE__ */ jsx(EnvironmentMap, { ...props, map: texture }),
397
- /* @__PURE__ */ jsx("groundProjectedEnvImpl", { args, scale })
398
- ] });
399
- }
400
- function EnvironmentColor({ color, scene }) {
401
- const defaultScene = useThree$1((state) => state.scene);
402
- React.useLayoutEffect(() => {
403
- if (color === void 0) return;
404
- const target = resolveScene(scene || defaultScene);
405
- const oldBg = target.background;
406
- target.background = new Color(color);
407
- return () => {
408
- target.background = oldBg;
409
- };
410
- });
411
- return null;
412
- }
413
- function EnvironmentDualSource(props) {
414
- const { backgroundFiles, ...envProps } = props;
415
- return /* @__PURE__ */ jsxs(Fragment, { children: [
416
- /* @__PURE__ */ jsx(EnvironmentCube, { ...envProps, background: false }),
417
- /* @__PURE__ */ jsx(EnvironmentCube, { ...props, files: backgroundFiles, background: "only" })
418
- ] });
258
+ }
259
+ return data;
419
260
  }
420
- function Environment(props) {
421
- if (props.color && !props.files && !props.preset && !props.map) {
422
- return /* @__PURE__ */ jsx(EnvironmentColor, { ...props });
261
+ function dispose(obj) {
262
+ if (obj.type !== "Scene") obj.dispose?.();
263
+ for (const p in obj) {
264
+ const prop = obj[p];
265
+ if (prop?.type !== "Scene") prop?.dispose?.();
423
266
  }
424
- if (props.backgroundFiles && props.backgroundFiles !== props.files) {
425
- return /* @__PURE__ */ jsx(EnvironmentDualSource, { ...props });
267
+ }
268
+ function getInstanceProps(pendingProps) {
269
+ const props = {};
270
+ for (const key in pendingProps) {
271
+ if (!REACT_INTERNAL_PROPS.includes(key)) props[key] = pendingProps[key];
426
272
  }
427
- return props.ground ? /* @__PURE__ */ jsx(EnvironmentGround, { ...props }) : props.map ? /* @__PURE__ */ jsx(EnvironmentMap, { ...props }) : props.children ? /* @__PURE__ */ jsx(EnvironmentPortal, { ...props }) : /* @__PURE__ */ jsx(EnvironmentCube, { ...props });
273
+ return props;
428
274
  }
429
-
430
- var __defProp = Object.defineProperty;
431
- var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
432
- var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
433
- const act = React["act"];
434
- const useIsomorphicLayoutEffect = /* @__PURE__ */ (() => typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative"))() ? React.useLayoutEffect : React.useEffect;
435
- function useMutableCallback(fn) {
436
- const ref = React.useRef(fn);
437
- useIsomorphicLayoutEffect(() => void (ref.current = fn), [fn]);
438
- return ref;
275
+ function prepare(target, root, type, props) {
276
+ const object = target;
277
+ let instance = object?.__r3f;
278
+ if (!instance) {
279
+ instance = {
280
+ root,
281
+ type,
282
+ parent: null,
283
+ children: [],
284
+ props: getInstanceProps(props),
285
+ object,
286
+ eventCount: 0,
287
+ handlers: {},
288
+ isHidden: false
289
+ };
290
+ if (object) object.__r3f = instance;
291
+ }
292
+ return instance;
439
293
  }
440
- function useBridge() {
441
- const fiber = useFiber();
442
- const ContextBridge = useContextBridge();
443
- return React.useMemo(
444
- () => ({ children }) => {
445
- const strict = !!traverseFiber(fiber, true, (node) => node.type === React.StrictMode);
446
- const Root = strict ? React.StrictMode : React.Fragment;
447
- return /* @__PURE__ */ jsx(Root, { children: /* @__PURE__ */ jsx(ContextBridge, { children }) });
448
- },
449
- [fiber, ContextBridge]
450
- );
294
+ function invalidateInstance(instance) {
295
+ if (!instance.parent) return;
296
+ instance.props.onUpdate?.(instance.object);
297
+ const state = instance.root?.getState?.();
298
+ if (state && state.internal.frames === 0) state.invalidate();
451
299
  }
452
- function Block({ set }) {
453
- useIsomorphicLayoutEffect(() => {
454
- set(new Promise(() => null));
455
- return () => set(false);
456
- }, [set]);
457
- return null;
300
+
301
+ const tempFrustum = new Frustum();
302
+ let hasWarnedWebGL = false;
303
+ let tslModule = null;
304
+ async function loadTSL() {
305
+ if (tslModule) return tslModule;
306
+ try {
307
+ const tsl = await import('three/tsl');
308
+ tslModule = { uniform: tsl.uniform, nodeObject: tsl.nodeObject };
309
+ return tslModule;
310
+ } catch {
311
+ return null;
312
+ }
458
313
  }
459
- const ErrorBoundary = /* @__PURE__ */ (() => {
460
- var _a;
461
- return _a = class extends React.Component {
462
- constructor() {
463
- super(...arguments);
464
- __publicField(this, "state", { error: false });
465
- }
466
- componentDidCatch(err) {
467
- this.props.set(err);
468
- }
469
- render() {
470
- return this.state.error ? null : this.props.children;
471
- }
472
- }, __publicField(_a, "getDerivedStateFromError", () => ({ error: true })), _a;
473
- })();
474
-
475
- const is = {
476
- obj: (a) => a === Object(a) && !is.arr(a) && typeof a !== "function",
477
- fun: (a) => typeof a === "function",
478
- str: (a) => typeof a === "string",
479
- num: (a) => typeof a === "number",
480
- boo: (a) => typeof a === "boolean",
481
- und: (a) => a === void 0,
482
- nul: (a) => a === null,
483
- arr: (a) => Array.isArray(a),
484
- equ(a, b, { arrays = "shallow", objects = "reference", strict = true } = {}) {
485
- if (typeof a !== typeof b || !!a !== !!b) return false;
486
- if (is.str(a) || is.num(a) || is.boo(a)) return a === b;
487
- const isObj = is.obj(a);
488
- if (isObj && objects === "reference") return a === b;
489
- const isArr = is.arr(a);
490
- if (isArr && arrays === "reference") return a === b;
491
- if ((isArr || isObj) && a === b) return true;
492
- let i;
493
- for (i in a) if (!(i in b)) return false;
494
- if (isObj && arrays === "shallow" && objects === "shallow") {
495
- for (i in strict ? b : a) if (!is.equ(a[i], b[i], { strict, objects: "reference" })) return false;
496
- } else {
497
- for (i in strict ? b : a) if (a[i] !== b[i]) return false;
498
- }
499
- if (is.und(i)) {
500
- if (isArr && a.length === 0 && b.length === 0) return true;
501
- if (isObj && Object.keys(a).length === 0 && Object.keys(b).length === 0) return true;
502
- if (a !== b) return false;
503
- }
504
- return true;
505
- }
506
- };
507
- const isOrthographicCamera = (def) => def && def.isOrthographicCamera;
508
- const isRef = (obj) => obj !== null && typeof obj === "object" && obj.hasOwnProperty("current");
509
- const isColorRepresentation = (value) => value != null && (typeof value === "string" || typeof value === "number" || value.isColor);
510
- const isObject3D = (object) => object?.isObject3D;
511
- const isTexture = (value) => !!value?.isTexture;
512
- const isVectorLike = (object) => object !== null && typeof object === "object" && "set" in object && typeof object.set === "function";
513
- const isCopyable = (object) => isVectorLike(object) && "copy" in object && typeof object.copy === "function";
514
- const hasConstructor = (object) => !!object?.constructor;
515
-
516
- function calculateDpr(dpr) {
517
- const target = typeof window !== "undefined" ? window.devicePixelRatio ?? 2 : 1;
518
- return Array.isArray(dpr) ? Math.min(Math.max(dpr[0], target), dpr[1]) : dpr;
519
- }
520
- function getUuidPrefix(uuid) {
521
- return uuid.split("-")[0];
522
- }
523
- function updateCamera(camera, size) {
524
- if (camera.manual) return;
525
- if (isOrthographicCamera(camera)) {
526
- camera.left = size.width / -2;
527
- camera.right = size.width / 2;
528
- camera.top = size.height / 2;
529
- camera.bottom = size.height / -2;
530
- } else {
531
- camera.aspect = size.width / size.height;
532
- }
533
- camera.updateProjectionMatrix();
534
- }
535
- const frustumMatrix = new Matrix4();
536
- function updateFrustum(camera, frustum) {
537
- const target = frustum ?? new Frustum();
538
- frustumMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
539
- target.setFromProjectionMatrix(frustumMatrix);
540
- return target;
541
- }
542
-
543
- const REACT_INTERNAL_PROPS = ["children", "key", "ref"];
544
- function findInitialRoot(instance) {
545
- let root = instance.root;
546
- while (root.getState().previousRoot) root = root.getState().previousRoot;
547
- return root;
548
- }
549
- function getRootState(obj) {
550
- let state = obj.__r3f?.root.getState();
551
- if (!state) {
552
- obj.traverseAncestors((ancestor) => {
553
- const parentState = ancestor.__r3f?.root.getState();
554
- if (parentState) {
555
- state = parentState;
556
- return false;
557
- }
558
- });
559
- }
560
- return state;
561
- }
562
- function buildGraph(object) {
563
- const data = { nodes: {}, materials: {}, meshes: {} };
564
- if (object) {
565
- object.traverse((obj) => {
566
- if (obj.name) data.nodes[obj.name] = obj;
567
- if (obj.material) {
568
- const material = Array.isArray(obj.material) ? obj.material[0] : obj.material;
569
- const nameAlreadyUsed = data.materials[material.name];
570
- let materialName = material.name;
571
- if (nameAlreadyUsed) {
572
- materialName = materialName + `-${getUuidPrefix(material.uuid)}`;
573
- material.userData.materialCacheName = materialName;
574
- }
575
- data.materials[materialName] = material;
576
- }
577
- if (obj.isMesh && !data.meshes[obj.name]) data.meshes[obj.name] = obj;
578
- });
579
- }
580
- return data;
581
- }
582
- function dispose(obj) {
583
- if (obj.type !== "Scene") obj.dispose?.();
584
- for (const p in obj) {
585
- const prop = obj[p];
586
- if (prop?.type !== "Scene") prop?.dispose?.();
587
- }
588
- }
589
- function getInstanceProps(pendingProps) {
590
- const props = {};
591
- for (const key in pendingProps) {
592
- if (!REACT_INTERNAL_PROPS.includes(key)) props[key] = pendingProps[key];
593
- }
594
- return props;
595
- }
596
- function prepare(target, root, type, props) {
597
- const object = target;
598
- let instance = object?.__r3f;
599
- if (!instance) {
600
- instance = {
601
- root,
602
- type,
603
- parent: null,
604
- children: [],
605
- props: getInstanceProps(props),
606
- object,
607
- eventCount: 0,
608
- handlers: {},
609
- isHidden: false
610
- };
611
- if (object) object.__r3f = instance;
612
- }
613
- return instance;
614
- }
615
- function invalidateInstance(instance) {
616
- if (!instance.parent) return;
617
- instance.props.onUpdate?.(instance.object);
618
- const state = instance.root?.getState?.();
619
- if (state && state.internal.frames === 0) state.invalidate();
620
- }
621
-
622
- const tempFrustum = new Frustum();
623
- let hasWarnedWebGL = false;
624
- let tslModule = null;
625
- async function loadTSL() {
626
- if (tslModule) return tslModule;
627
- try {
628
- const tsl = await import('three/tsl');
629
- tslModule = { uniform: tsl.uniform, nodeObject: tsl.nodeObject };
630
- return tslModule;
631
- } catch {
632
- return null;
633
- }
634
- }
635
- function createOcclusionObserverNode(store, uniform) {
636
- const node = new Node("float");
637
- node.updateType = NodeUpdateType.OBJECT;
638
- node.update = function(frame) {
639
- const { internal } = store.getState();
640
- const registry = internal.visibilityRegistry;
641
- const cache = internal.occlusionCache;
642
- for (const entry of registry.values()) {
643
- const { object, handlers } = entry;
644
- if (handlers.onOccluded || handlers.onVisible) {
645
- const isOccluded = frame.renderer.isOccluded(object);
646
- cache.set(object, isOccluded);
647
- }
314
+ function createOcclusionObserverNode(store, uniform) {
315
+ const node = new Node("float");
316
+ node.updateType = NodeUpdateType.OBJECT;
317
+ node.update = function(frame) {
318
+ const { internal } = store.getState();
319
+ const registry = internal.visibilityRegistry;
320
+ const cache = internal.occlusionCache;
321
+ for (const entry of registry.values()) {
322
+ const { object, handlers } = entry;
323
+ if (handlers.onOccluded || handlers.onVisible) {
324
+ const isOccluded = frame.renderer.isOccluded(object);
325
+ cache.set(object, isOccluded);
326
+ }
648
327
  }
649
328
  };
650
329
  node.setup = function() {
@@ -934,9 +613,9 @@ function diffProps(instance, newProps) {
934
613
  const { root, key } = resolve(instance.object, prop);
935
614
  if (root.constructor && root.constructor.length === 0) {
936
615
  const ctor = getMemoizedPrototype(root);
937
- if (!is.und(ctor)) changedProps[key] = ctor[key];
616
+ if (!is.und(ctor)) changedProps[prop] = ctor[key];
938
617
  } else {
939
- changedProps[key] = 0;
618
+ changedProps[prop] = 0;
940
619
  }
941
620
  }
942
621
  return changedProps;
@@ -1053,614 +732,68 @@ function applyProps(object, props) {
1053
732
  return object;
1054
733
  }
1055
734
 
1056
- const DEFAULT_POINTER_ID = 0;
1057
- const XR_POINTER_ID_START = 1e3;
1058
- function getPointerState(internal, pointerId) {
1059
- let state = internal.pointerMap.get(pointerId);
1060
- if (!state) {
1061
- state = {
1062
- hovered: /* @__PURE__ */ new Map(),
1063
- captured: /* @__PURE__ */ new Map(),
1064
- initialClick: [0, 0],
1065
- initialHits: []
1066
- };
1067
- internal.pointerMap.set(pointerId, state);
735
+ const shownNotices = /* @__PURE__ */ new Set();
736
+ function notifyDepreciated({ heading, body, link }) {
737
+ if (typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) && process.env.R3F_SHOW_DEPRECATION_WARNINGS !== "true") {
738
+ return;
739
+ }
740
+ if (shownNotices.has(heading)) return;
741
+ shownNotices.add(heading);
742
+ const caller = getCallerFrame();
743
+ if (caller) {
744
+ console.log();
745
+ }
746
+ const boxStyle = "background: #ff9800; color: #1a1a1a; padding: 8px 12px; border-radius: 4px; font-weight: 500;";
747
+ if (caller) {
748
+ console.log(`%c\u26A0\uFE0F ${heading}`, boxStyle);
749
+ }
750
+ if (body || link) {
751
+ let message = "";
752
+ if (body) message += body;
753
+ if (link) message += (body ? "\n\n" : "") + `More info: ${link}`;
754
+ console.warn(`%c${message}`, "font-weight: bold;");
1068
755
  }
1069
- return state;
1070
756
  }
1071
- function getPointerId(event) {
1072
- return "pointerId" in event ? event.pointerId : DEFAULT_POINTER_ID;
757
+ function getCallerFrame(depth = 3) {
758
+ const stack = new Error().stack;
759
+ if (!stack) return null;
760
+ const lines = stack.split("\n");
761
+ const frame = lines[depth];
762
+ if (!frame) return null;
763
+ let match = frame.match(/^\s*at (?:(.+?) )?\(?(.+?):(\d+):(\d+)\)?$/);
764
+ if (!match) {
765
+ match = frame.match(/^(?:(.+?)@)?(.+?):(\d+):(\d+)$/);
766
+ }
767
+ if (!match) return null;
768
+ const [, fn, url, line] = match;
769
+ return {
770
+ functionName: fn ?? "<anonymous>",
771
+ location: formatLocation(url, Number(line))
772
+ };
1073
773
  }
1074
- function makeId(event) {
1075
- return (event.eventObject || event.object).uuid + "/" + event.index + event.instanceId;
774
+ function formatLocation(url, line) {
775
+ const clean = url.split("?")[0];
776
+ const file = clean.split("/").pop() ?? clean;
777
+ return `${file}:${line}`;
1076
778
  }
1077
- function releaseInternalPointerCapture(internal, obj, pointerId) {
1078
- const pointerState = internal.pointerMap.get(pointerId);
1079
- if (!pointerState) return;
1080
- const captureData = pointerState.captured.get(obj);
1081
- if (captureData) {
1082
- pointerState.captured.delete(obj);
1083
- captureData.target.releasePointerCapture(pointerId);
1084
- }
1085
- }
1086
- function removeInteractivity(store, object) {
1087
- const { internal } = store.getState();
1088
- internal.interaction = internal.interaction.filter((o) => o !== object);
1089
- for (const [pointerId, pointerState] of internal.pointerMap) {
1090
- pointerState.initialHits = pointerState.initialHits.filter((o) => o !== object);
1091
- pointerState.hovered.forEach((value, key) => {
1092
- if (value.eventObject === object || value.object === object) {
1093
- pointerState.hovered.delete(key);
1094
- }
1095
- });
1096
- if (pointerState.captured.has(object)) {
1097
- releaseInternalPointerCapture(internal, object, pointerId);
1098
- }
1099
- }
1100
- unregisterVisibility(store, object);
1101
- }
1102
- function createEvents(store) {
1103
- function calculateDistance(event, pointerId) {
1104
- const { internal } = store.getState();
1105
- const pointerState = internal.pointerMap.get(pointerId);
1106
- if (!pointerState) return 0;
1107
- const [initialX, initialY] = pointerState.initialClick;
1108
- const dx = event.offsetX - initialX;
1109
- const dy = event.offsetY - initialY;
1110
- return Math.round(Math.sqrt(dx * dx + dy * dy));
1111
- }
1112
- function filterPointerEvents(objects) {
1113
- return objects.filter(
1114
- (obj) => ["Move", "Over", "Enter", "Out", "Leave"].some(
1115
- (name) => obj.__r3f?.handlers["onPointer" + name]
1116
- ) || ["OverEnter", "OverLeave", "Over"].some(
1117
- (name) => obj.__r3f?.handlers["onDrag" + name]
1118
- ) || obj.__r3f?.handlers.onDrop
1119
- );
1120
- }
1121
- function intersect(event, filter) {
1122
- const state = store.getState();
1123
- const duplicates = /* @__PURE__ */ new Set();
1124
- const intersections = [];
1125
- const eventsObjects = filter ? filter(state.internal.interaction) : state.internal.interaction;
1126
- for (let i = 0; i < eventsObjects.length; i++) {
1127
- const state2 = getRootState(eventsObjects[i]);
1128
- if (state2) {
1129
- state2.raycaster.camera = void 0;
1130
- }
1131
- }
1132
- if (!state.previousRoot) {
1133
- state.events.compute?.(event, state);
1134
- }
1135
- function handleRaycast(obj) {
1136
- const state2 = getRootState(obj);
1137
- if (!state2 || !state2.events.enabled || state2.raycaster.camera === null) return [];
1138
- if (state2.raycaster.camera === void 0) {
1139
- state2.events.compute?.(event, state2, state2.previousRoot?.getState());
1140
- if (state2.raycaster.camera === void 0) state2.raycaster.camera = null;
1141
- }
1142
- return state2.raycaster.camera ? state2.raycaster.intersectObject(obj, true) : [];
1143
- }
1144
- let hits = eventsObjects.flatMap(handleRaycast).sort((a, b) => {
1145
- const aInteractivePriority = a.object.userData?.interactivePriority;
1146
- const bInteractivePriority = b.object.userData?.interactivePriority;
1147
- if (aInteractivePriority !== void 0 || bInteractivePriority !== void 0) {
1148
- if (aInteractivePriority !== void 0 && bInteractivePriority === void 0) return -1;
1149
- if (bInteractivePriority !== void 0 && aInteractivePriority === void 0) return 1;
1150
- if (aInteractivePriority !== bInteractivePriority) {
1151
- return (bInteractivePriority ?? 0) - (aInteractivePriority ?? 0);
1152
- }
1153
- }
1154
- const aState = getRootState(a.object);
1155
- const bState = getRootState(b.object);
1156
- const aPriority = aState?.events?.priority ?? 1;
1157
- const bPriority = bState?.events?.priority ?? 1;
1158
- return bPriority - aPriority || a.distance - b.distance;
1159
- }).filter((item) => {
1160
- const id = makeId(item);
1161
- if (duplicates.has(id)) return false;
1162
- duplicates.add(id);
1163
- return true;
1164
- });
1165
- if (state.events.filter) hits = state.events.filter(hits, state);
1166
- for (const hit of hits) {
1167
- let eventObject = hit.object;
1168
- while (eventObject) {
1169
- if (eventObject.__r3f?.eventCount) {
1170
- intersections.push({ ...hit, eventObject });
1171
- }
1172
- eventObject = eventObject.parent;
1173
- }
1174
- }
1175
- if ("pointerId" in event) {
1176
- const pointerId = event.pointerId;
1177
- const pointerState = state.internal.pointerMap.get(pointerId);
1178
- if (pointerState?.captured.size) {
1179
- for (const captureData of pointerState.captured.values()) {
1180
- if (!duplicates.has(makeId(captureData.intersection))) intersections.push(captureData.intersection);
1181
- }
1182
- }
1183
- }
1184
- return intersections;
1185
- }
1186
- function handleIntersects(intersections, event, delta, callback) {
1187
- if (intersections.length) {
1188
- const localState = { stopped: false };
1189
- for (const hit of intersections) {
1190
- const state = getRootState(hit.object);
1191
- if (state) {
1192
- const { raycaster, pointer, camera, internal } = state;
1193
- const unprojectedPoint = new Vector3(pointer.x, pointer.y, 0).unproject(camera);
1194
- const hasPointerCapture = (id) => {
1195
- const pointerState = internal.pointerMap.get(id);
1196
- return pointerState?.captured.has(hit.eventObject) ?? false;
1197
- };
1198
- const setPointerCapture = (id) => {
1199
- const captureData = { intersection: hit, target: event.target };
1200
- const pointerState = getPointerState(internal, id);
1201
- pointerState.captured.set(hit.eventObject, captureData);
1202
- event.target.setPointerCapture(id);
1203
- };
1204
- const releasePointerCapture = (id) => {
1205
- releaseInternalPointerCapture(internal, hit.eventObject, id);
1206
- };
1207
- const extractEventProps = {};
1208
- for (const prop in event) {
1209
- const property = event[prop];
1210
- if (typeof property !== "function") extractEventProps[prop] = property;
1211
- }
1212
- const eventPointerId = "pointerId" in event ? event.pointerId : void 0;
1213
- const raycastEvent = {
1214
- ...hit,
1215
- ...extractEventProps,
1216
- pointer,
1217
- intersections,
1218
- stopped: localState.stopped,
1219
- delta,
1220
- unprojectedPoint,
1221
- ray: raycaster.ray,
1222
- camera,
1223
- pointerId: eventPointerId,
1224
- // Hijack stopPropagation, which just sets a flag
1225
- stopPropagation() {
1226
- const pointerState = eventPointerId !== void 0 ? internal.pointerMap.get(eventPointerId) : void 0;
1227
- if (
1228
- // ...if this pointer hasn't been captured
1229
- !pointerState?.captured.size || // ... or if the hit object is capturing the pointer
1230
- pointerState.captured.has(hit.eventObject)
1231
- ) {
1232
- raycastEvent.stopped = localState.stopped = true;
1233
- if (pointerState?.hovered.size && Array.from(pointerState.hovered.values()).find((i) => i.eventObject === hit.eventObject)) {
1234
- const higher = intersections.slice(0, intersections.indexOf(hit));
1235
- cancelPointer([...higher, hit], eventPointerId);
1236
- }
1237
- }
1238
- },
1239
- // there should be a distinction between target and currentTarget
1240
- target: { hasPointerCapture, setPointerCapture, releasePointerCapture },
1241
- currentTarget: { hasPointerCapture, setPointerCapture, releasePointerCapture },
1242
- nativeEvent: event
1243
- };
1244
- callback(raycastEvent);
1245
- if (localState.stopped === true) break;
1246
- }
1247
- }
1248
- }
1249
- return intersections;
1250
- }
1251
- function cancelPointer(intersections, pointerId) {
1252
- const { internal } = store.getState();
1253
- const pid = pointerId ?? DEFAULT_POINTER_ID;
1254
- const pointerState = internal.pointerMap.get(pid);
1255
- if (!pointerState) return;
1256
- for (const [hoveredId, hoveredObj] of pointerState.hovered) {
1257
- if (!intersections.length || !intersections.find(
1258
- (hit) => hit.object === hoveredObj.object && hit.index === hoveredObj.index && hit.instanceId === hoveredObj.instanceId
1259
- )) {
1260
- const eventObject = hoveredObj.eventObject;
1261
- const instance = eventObject.__r3f;
1262
- pointerState.hovered.delete(hoveredId);
1263
- if (instance?.eventCount) {
1264
- const handlers = instance.handlers;
1265
- const data = { ...hoveredObj, intersections };
1266
- handlers.onPointerOut?.(data);
1267
- handlers.onPointerLeave?.(data);
1268
- handlers.onDragOverLeave?.(data);
1269
- }
1270
- }
1271
- }
1272
- }
1273
- function pointerMissed(event, objects) {
1274
- for (let i = 0; i < objects.length; i++) {
1275
- const instance = objects[i].__r3f;
1276
- instance?.handlers.onPointerMissed?.(event);
1277
- }
1278
- }
1279
- function dragOverMissed(event, objects) {
1280
- for (let i = 0; i < objects.length; i++) {
1281
- const instance = objects[i].__r3f;
1282
- instance?.handlers.onDragOverMissed?.(event);
1283
- }
1284
- }
1285
- function dropMissed(event, objects) {
1286
- for (let i = 0; i < objects.length; i++) {
1287
- const instance = objects[i].__r3f;
1288
- instance?.handlers.onDropMissed?.(event);
1289
- }
1290
- }
1291
- function cleanupPointer(pointerId) {
1292
- const { internal } = store.getState();
1293
- const pointerState = internal.pointerMap.get(pointerId);
1294
- if (pointerState) {
1295
- for (const [, hoveredObj] of pointerState.hovered) {
1296
- const eventObject = hoveredObj.eventObject;
1297
- const instance = eventObject.__r3f;
1298
- if (instance?.eventCount) {
1299
- const handlers = instance.handlers;
1300
- const data = { ...hoveredObj, intersections: [] };
1301
- handlers.onPointerOut?.(data);
1302
- handlers.onPointerLeave?.(data);
1303
- }
1304
- }
1305
- internal.pointerMap.delete(pointerId);
1306
- }
1307
- internal.pointerDirty.delete(pointerId);
1308
- }
1309
- function processDeferredPointer(event, pointerId) {
1310
- const state = store.getState();
1311
- const { internal } = state;
1312
- if (!state.events.enabled) return;
1313
- const filter = filterPointerEvents;
1314
- const hits = intersect(event, filter);
1315
- cancelPointer(hits, pointerId);
1316
- function onIntersect(data) {
1317
- const eventObject = data.eventObject;
1318
- const instance = eventObject.__r3f;
1319
- if (!instance?.eventCount) return;
1320
- const handlers = instance.handlers;
1321
- if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) {
1322
- const id = makeId(data);
1323
- const pointerState = getPointerState(internal, pointerId);
1324
- const hoveredItem = pointerState.hovered.get(id);
1325
- if (!hoveredItem) {
1326
- pointerState.hovered.set(id, data);
1327
- handlers.onPointerOver?.(data);
1328
- handlers.onPointerEnter?.(data);
1329
- } else if (hoveredItem.stopped) {
1330
- data.stopPropagation();
1331
- }
1332
- }
1333
- handlers.onPointerMove?.(data);
1334
- }
1335
- handleIntersects(hits, event, 0, onIntersect);
1336
- }
1337
- function handlePointer(name) {
1338
- switch (name) {
1339
- case "onPointerLeave":
1340
- case "onDragLeave":
1341
- return () => cancelPointer([]);
1342
- // Global cancel of these events
1343
- case "onPointerCancel":
1344
- return (event) => {
1345
- const pointerId = getPointerId(event);
1346
- cleanupPointer(pointerId);
1347
- };
1348
- case "onLostPointerCapture":
1349
- return (event) => {
1350
- const { internal } = store.getState();
1351
- const pointerId = getPointerId(event);
1352
- const pointerState = internal.pointerMap.get(pointerId);
1353
- if (pointerState?.captured.size) {
1354
- requestAnimationFrame(() => {
1355
- const pointerState2 = internal.pointerMap.get(pointerId);
1356
- if (pointerState2?.captured.size) {
1357
- pointerState2.captured.clear();
1358
- }
1359
- cancelPointer([], pointerId);
1360
- });
1361
- }
1362
- };
1363
- }
1364
- return function handleEvent(event) {
1365
- const state = store.getState();
1366
- const { onPointerMissed, onDragOverMissed, onDropMissed, internal, events } = state;
1367
- const pointerId = getPointerId(event);
1368
- internal.lastEvent.current = event;
1369
- if (!events.enabled) return;
1370
- const isPointerMove = name === "onPointerMove";
1371
- const isDragOver = name === "onDragOver";
1372
- const isDrop = name === "onDrop";
1373
- const isClickEvent = name === "onClick" || name === "onContextMenu" || name === "onDoubleClick";
1374
- const isPointerDown = name === "onPointerDown";
1375
- const isPointerUp = name === "onPointerUp";
1376
- const isWheel = name === "onWheel";
1377
- const canDeferRaycasts = events.frameTimedRaycasts && state.frameloop === "always";
1378
- if (isPointerMove && canDeferRaycasts) {
1379
- events.compute?.(event, state);
1380
- internal.pointerDirty.set(pointerId, event);
1381
- return;
1382
- }
1383
- if (isWheel && canDeferRaycasts && !events.alwaysFireOnScroll) {
1384
- events.compute?.(event, state);
1385
- internal.pointerDirty.set(pointerId, event);
1386
- return;
1387
- }
1388
- if ((isClickEvent || isPointerDown || isPointerUp) && internal.pointerDirty.has(pointerId)) {
1389
- const deferredEvent = internal.pointerDirty.get(pointerId);
1390
- internal.pointerDirty.delete(pointerId);
1391
- processDeferredPointer(deferredEvent, pointerId);
1392
- }
1393
- const filter = isPointerMove || isDragOver || isDrop ? filterPointerEvents : void 0;
1394
- const hits = intersect(event, filter);
1395
- const delta = isClickEvent ? calculateDistance(event, pointerId) : 0;
1396
- if (isPointerDown) {
1397
- const pointerState2 = getPointerState(internal, pointerId);
1398
- pointerState2.initialClick = [event.offsetX, event.offsetY];
1399
- pointerState2.initialHits = hits.map((hit) => hit.eventObject);
1400
- }
1401
- const pointerState = internal.pointerMap.get(pointerId);
1402
- const initialHits = pointerState?.initialHits ?? [];
1403
- if (isClickEvent && !hits.length) {
1404
- if (delta <= 2) {
1405
- pointerMissed(event, internal.interaction);
1406
- if (onPointerMissed) onPointerMissed(event);
1407
- }
1408
- }
1409
- if (isDragOver && !hits.length) {
1410
- dragOverMissed(event, internal.interaction);
1411
- if (onDragOverMissed) onDragOverMissed(event);
1412
- }
1413
- if (isDrop && !hits.length) {
1414
- dropMissed(event, internal.interaction);
1415
- if (onDropMissed) onDropMissed(event);
1416
- }
1417
- if (isPointerMove || isDragOver) {
1418
- cancelPointer(hits, pointerId);
1419
- }
1420
- function onIntersect(data) {
1421
- const eventObject = data.eventObject;
1422
- const instance = eventObject.__r3f;
1423
- if (!instance?.eventCount) return;
1424
- const handlers = instance.handlers;
1425
- if (isPointerMove) {
1426
- if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) {
1427
- const id = makeId(data);
1428
- const pointerState2 = getPointerState(internal, pointerId);
1429
- const hoveredItem = pointerState2.hovered.get(id);
1430
- if (!hoveredItem) {
1431
- pointerState2.hovered.set(id, data);
1432
- handlers.onPointerOver?.(data);
1433
- handlers.onPointerEnter?.(data);
1434
- } else if (hoveredItem.stopped) {
1435
- data.stopPropagation();
1436
- }
1437
- }
1438
- handlers.onPointerMove?.(data);
1439
- } else if (isDragOver) {
1440
- const id = makeId(data);
1441
- const pointerState2 = getPointerState(internal, pointerId);
1442
- const hoveredItem = pointerState2.hovered.get(id);
1443
- if (!hoveredItem) {
1444
- pointerState2.hovered.set(id, data);
1445
- handlers.onDragOverEnter?.(data);
1446
- } else if (hoveredItem.stopped) {
1447
- data.stopPropagation();
1448
- }
1449
- handlers.onDragOver?.(data);
1450
- } else if (isDrop) {
1451
- handlers.onDrop?.(data);
1452
- } else {
1453
- const handler = handlers[name];
1454
- if (handler) {
1455
- if (!isClickEvent || initialHits.includes(eventObject)) {
1456
- pointerMissed(
1457
- event,
1458
- internal.interaction.filter((object) => !initialHits.includes(object))
1459
- );
1460
- handler(data);
1461
- }
1462
- } else {
1463
- if (isClickEvent && initialHits.includes(eventObject)) {
1464
- pointerMissed(
1465
- event,
1466
- internal.interaction.filter((object) => !initialHits.includes(object))
1467
- );
1468
- }
1469
- }
1470
- }
1471
- }
1472
- handleIntersects(hits, event, delta, onIntersect);
1473
- };
1474
- }
1475
- function flushDeferredPointers() {
1476
- const { internal, events } = store.getState();
1477
- if (!events.frameTimedRaycasts) return;
1478
- for (const [pointerId, event] of internal.pointerDirty) {
1479
- processDeferredPointer(event, pointerId);
1480
- }
1481
- internal.pointerDirty.clear();
1482
- }
1483
- return { handlePointer, flushDeferredPointers, processDeferredPointer };
1484
- }
1485
- const DOM_EVENTS = {
1486
- onClick: ["click", false],
1487
- onContextMenu: ["contextmenu", false],
1488
- onDoubleClick: ["dblclick", false],
1489
- onDragEnter: ["dragenter", false],
1490
- onDragLeave: ["dragleave", false],
1491
- onDragOver: ["dragover", false],
1492
- onDrop: ["drop", false],
1493
- onWheel: ["wheel", true],
1494
- onPointerDown: ["pointerdown", true],
1495
- onPointerUp: ["pointerup", true],
1496
- onPointerLeave: ["pointerleave", true],
1497
- onPointerMove: ["pointermove", true],
1498
- onPointerCancel: ["pointercancel", true],
1499
- onLostPointerCapture: ["lostpointercapture", true]
1500
- };
1501
- function createPointerEvents(store) {
1502
- const { handlePointer, flushDeferredPointers, processDeferredPointer } = createEvents(store);
1503
- let nextXRPointerId = XR_POINTER_ID_START;
1504
- const xrPointers = /* @__PURE__ */ new Map();
1505
- return {
1506
- priority: 1,
1507
- enabled: true,
1508
- frameTimedRaycasts: true,
1509
- alwaysFireOnScroll: true,
1510
- updateOnFrame: false,
1511
- compute(event, state) {
1512
- state.pointer.set(event.offsetX / state.size.width * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
1513
- state.raycaster.setFromCamera(state.pointer, state.camera);
1514
- },
1515
- connected: void 0,
1516
- handlers: Object.keys(DOM_EVENTS).reduce(
1517
- (acc, key) => ({ ...acc, [key]: handlePointer(key) }),
1518
- {}
1519
- ),
1520
- update: (pointerId) => {
1521
- const { events, internal } = store.getState();
1522
- if (!events.handlers) return;
1523
- if (pointerId !== void 0) {
1524
- const event = internal.pointerDirty.get(pointerId);
1525
- if (event) {
1526
- internal.pointerDirty.delete(pointerId);
1527
- processDeferredPointer(event, pointerId);
1528
- } else if (internal.lastEvent?.current) {
1529
- processDeferredPointer(internal.lastEvent.current, pointerId);
1530
- }
1531
- } else {
1532
- flushDeferredPointers();
1533
- if (internal.lastEvent?.current) {
1534
- events.handlers.onPointerMove(internal.lastEvent.current);
1535
- }
1536
- }
1537
- },
1538
- flush: () => {
1539
- const { events, internal } = store.getState();
1540
- flushDeferredPointers();
1541
- if (events.updateOnFrame && internal.lastEvent?.current && events.handlers) {
1542
- events.handlers.onPointerMove(internal.lastEvent.current);
1543
- }
1544
- },
1545
- connect: (target) => {
1546
- if (!target) return;
1547
- const { set, events } = store.getState();
1548
- events.disconnect?.();
1549
- set((state) => ({ events: { ...state.events, connected: target } }));
1550
- if (events.handlers) {
1551
- for (const name in events.handlers) {
1552
- const event = events.handlers[name];
1553
- const [eventName, passive] = DOM_EVENTS[name];
1554
- target.addEventListener(eventName, event, { passive });
1555
- }
1556
- }
1557
- },
1558
- disconnect: () => {
1559
- const { set, events } = store.getState();
1560
- if (events.connected) {
1561
- if (events.handlers) {
1562
- for (const name in events.handlers) {
1563
- const event = events.handlers[name];
1564
- const [eventName] = DOM_EVENTS[name];
1565
- events.connected.removeEventListener(eventName, event);
1566
- }
1567
- }
1568
- set((state) => ({ events: { ...state.events, connected: void 0 } }));
1569
- }
1570
- },
1571
- // PREVIEW (A8): the XR pointer registration API may change before stable.
1572
- registerPointer: (config) => {
1573
- const pointerId = nextXRPointerId++;
1574
- xrPointers.set(pointerId, config);
1575
- const { internal } = store.getState();
1576
- getPointerState(internal, pointerId);
1577
- return pointerId;
1578
- },
1579
- unregisterPointer: (pointerId) => {
1580
- xrPointers.delete(pointerId);
1581
- const { internal } = store.getState();
1582
- const pointerState = internal.pointerMap.get(pointerId);
1583
- if (pointerState) {
1584
- for (const [, hoveredObj] of pointerState.hovered) {
1585
- const eventObject = hoveredObj.eventObject;
1586
- const instance = eventObject.__r3f;
1587
- if (instance?.eventCount) {
1588
- const handlers = instance.handlers;
1589
- const data = { ...hoveredObj, intersections: [] };
1590
- handlers.onPointerOut?.(data);
1591
- handlers.onPointerLeave?.(data);
1592
- }
1593
- }
1594
- internal.pointerMap.delete(pointerId);
1595
- }
1596
- internal.pointerDirty.delete(pointerId);
1597
- }
1598
- };
1599
- }
1600
-
1601
- const shownNotices = /* @__PURE__ */ new Set();
1602
- function notifyDepreciated({ heading, body, link }) {
1603
- if (typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) && process.env.R3F_SHOW_DEPRECATION_WARNINGS !== "true") {
1604
- return;
1605
- }
1606
- if (shownNotices.has(heading)) return;
1607
- shownNotices.add(heading);
1608
- const caller = getCallerFrame();
1609
- if (caller) {
1610
- console.log();
1611
- }
1612
- const boxStyle = "background: #ff9800; color: #1a1a1a; padding: 8px 12px; border-radius: 4px; font-weight: 500;";
1613
- if (caller) {
1614
- console.log(`%c\u26A0\uFE0F ${heading}`, boxStyle);
1615
- }
1616
- if (body || link) {
1617
- let message = "";
1618
- if (body) message += body;
1619
- if (link) message += (body ? "\n\n" : "") + `More info: ${link}`;
1620
- console.warn(`%c${message}`, "font-weight: bold;");
1621
- }
1622
- }
1623
- function getCallerFrame(depth = 3) {
1624
- const stack = new Error().stack;
1625
- if (!stack) return null;
1626
- const lines = stack.split("\n");
1627
- const frame = lines[depth];
1628
- if (!frame) return null;
1629
- let match = frame.match(/^\s*at (?:(.+?) )?\(?(.+?):(\d+):(\d+)\)?$/);
1630
- if (!match) {
1631
- match = frame.match(/^(?:(.+?)@)?(.+?):(\d+):(\d+)$/);
1632
- }
1633
- if (!match) return null;
1634
- const [, fn, url, line] = match;
1635
- return {
1636
- functionName: fn ?? "<anonymous>",
1637
- location: formatLocation(url, Number(line))
1638
- };
1639
- }
1640
- function formatLocation(url, line) {
1641
- const clean = url.split("?")[0];
1642
- const file = clean.split("/").pop() ?? clean;
1643
- return `${file}:${line}`;
1644
- }
1645
- function notifyAlpha({ message, link }) {
1646
- if (typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) && process.env.R3F_SHOW_ALPHA_WARNINGS !== "true") {
1647
- return;
1648
- }
1649
- if (shownNotices.has(message)) return;
1650
- shownNotices.add(message);
1651
- const boxStyle = "background: #6366f1; color: #ffffff; padding: 6px 10px; border-radius: 4px; font-weight: 500;";
1652
- console.log(`%c\u{1F52C} ${message}`, boxStyle);
1653
- {
1654
- console.log(`%cMore info: ${link}`, "color: #6366f1; font-weight: normal;");
779
+ function notifyAlpha({ message, link }) {
780
+ if (typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) && process.env.R3F_SHOW_ALPHA_WARNINGS !== "true") {
781
+ return;
782
+ }
783
+ if (shownNotices.has(message)) return;
784
+ shownNotices.add(message);
785
+ const boxStyle = "background: #6366f1; color: #ffffff; padding: 6px 10px; border-radius: 4px; font-weight: 500;";
786
+ console.log(`%c\u{1F52C} ${message}`, boxStyle);
787
+ {
788
+ console.log(`%cMore info: ${link}`, "color: #6366f1; font-weight: normal;");
1655
789
  }
1656
790
  }
1657
791
 
1658
792
  const INTERNAL_LIB_MARKERS = ["zustand", "setState", "Object.assign"];
1659
- const INTERNAL_FIBER_MARKERS = ["packages/fiber/src", "packages/fiber/dist", "@react-three/fiber", "@react-three_fiber"];
1660
793
  function isInternalRendererAccess(stack, callerDepth = 2) {
1661
794
  if (!stack) return false;
1662
795
  const caller = stack.split("\n")[callerDepth] ?? "";
1663
- return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m)) || INTERNAL_FIBER_MARKERS.some((m) => caller.includes(m));
796
+ return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m));
1664
797
  }
1665
798
 
1666
799
  const R3F_CONTEXT = Symbol.for("@react-three/fiber.context");
@@ -1911,17 +1044,10 @@ const createStore = (invalidate, advance) => {
1911
1044
  oldSize = size;
1912
1045
  oldDpr = viewport.dpr;
1913
1046
  updateCamera(camera, size);
1914
- if (internal.isSecondary && canvasTarget) {
1915
- if (viewport.dpr > 0) canvasTarget.setPixelRatio(viewport.dpr);
1916
- canvasTarget.setSize(size.width, size.height, false);
1917
- } else {
1918
- if (viewport.dpr > 0) actualRenderer.setPixelRatio(viewport.dpr);
1919
- actualRenderer.setSize(size.width, size.height, false);
1920
- if (canvasTarget) {
1921
- if (viewport.dpr > 0) canvasTarget.setPixelRatio(viewport.dpr);
1922
- canvasTarget.setSize(size.width, size.height, false);
1923
- }
1924
- }
1047
+ const resizeTarget = canvasTarget ?? actualRenderer;
1048
+ if (viewport.dpr > 0) resizeTarget.setPixelRatio(viewport.dpr);
1049
+ resizeTarget.setSize(size.width, size.height, false);
1050
+ internal.canvasTargetSizeDirty = true;
1925
1051
  }
1926
1052
  if (camera !== oldCamera) {
1927
1053
  oldCamera = camera;
@@ -1942,7 +1068,7 @@ const createStore = (invalidate, advance) => {
1942
1068
 
1943
1069
  const memoizedLoaders = /* @__PURE__ */ new WeakMap();
1944
1070
  const isConstructor$1 = (value) => typeof value === "function" && value?.prototype?.constructor === value;
1945
- function getLoader(Proto) {
1071
+ function getLoader$1(Proto) {
1946
1072
  if (isConstructor$1(Proto)) {
1947
1073
  let loader = memoizedLoaders.get(Proto);
1948
1074
  if (!loader) {
@@ -1955,7 +1081,7 @@ function getLoader(Proto) {
1955
1081
  }
1956
1082
  function loadingFn(extensions, onProgress) {
1957
1083
  return function(Proto, input) {
1958
- const loader = getLoader(Proto);
1084
+ const loader = getLoader$1(Proto);
1959
1085
  if (extensions) extensions(loader);
1960
1086
  if ("loadAsync" in loader && typeof loader.loadAsync === "function") {
1961
1087
  return loader.loadAsync(input, onProgress).then((data) => {
@@ -1983,7 +1109,11 @@ function useLoader(loader, input, extensions, onProgress, cacheKey) {
1983
1109
  const results = cacheKeys.map(
1984
1110
  (key, index) => suspend(() => fn(loader, inputs[index]), [loader, key], { equal: is.equ })
1985
1111
  );
1986
- return Array.isArray(input) ? results : results[0];
1112
+ const stableRef = useRef(null);
1113
+ const previous = stableRef.current;
1114
+ const stable = previous !== null && previous.length === results.length && previous.every((value, i) => value === results[i]) ? previous : results;
1115
+ stableRef.current = stable;
1116
+ return Array.isArray(input) ? stable : stable[0];
1987
1117
  }
1988
1118
  useLoader.preload = function(loader, input, extensions, onProgress, cacheKey) {
1989
1119
  const inputs = Array.isArray(input) ? input : [input];
@@ -1996,7 +1126,7 @@ useLoader.clear = function(loader, input, cacheKey) {
1996
1126
  const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
1997
1127
  cacheKeys.forEach((key) => clear([loader, key]));
1998
1128
  };
1999
- useLoader.loader = getLoader;
1129
+ useLoader.loader = getLoader$1;
2000
1130
 
2001
1131
  function useFrame(callback, priorityOrOptions) {
2002
1132
  const store = React.useContext(context);
@@ -2148,6 +1278,11 @@ function getUrls(input) {
2148
1278
  if (Array.isArray(input)) return input;
2149
1279
  return Object.values(input);
2150
1280
  }
1281
+ function inputSignature(input) {
1282
+ if (typeof input === "string") return input;
1283
+ if (Array.isArray(input)) return input.join("\0");
1284
+ return Object.keys(input).sort().map((key) => `${key}\0${input[key]}`).join("");
1285
+ }
2151
1286
  function allUrlsCached(urls, textureCache) {
2152
1287
  return urls.every((url) => textureCache.has(url));
2153
1288
  }
@@ -2173,18 +1308,19 @@ function useTexture(input, optionsOrOnLoad) {
2173
1308
  const onLoadRef = useRef(onLoad);
2174
1309
  onLoadRef.current = onLoad;
2175
1310
  const onLoadCalledForRef = useRef(null);
2176
- const urls = useMemo(() => getUrls(input), [input]);
1311
+ const inputKey = useMemo(() => inputSignature(input), [input]);
1312
+ const stableInput = useMemo(() => input, [inputKey]);
1313
+ const urls = useMemo(() => getUrls(stableInput), [stableInput]);
2177
1314
  const cachedResult = useMemo(() => {
2178
1315
  if (!cache) return null;
2179
1316
  const textures = store.getState().textures;
2180
1317
  if (!allUrlsCached(urls, textures)) return null;
2181
- return buildFromCache(input, textures);
2182
- }, [cache, urls, input, store]);
1318
+ return buildFromCache(stableInput, textures);
1319
+ }, [cache, urls, stableInput, store]);
2183
1320
  const loadedTextures = useLoader(
2184
1321
  TextureLoader,
2185
- IsObject(input) ? Object.values(input) : input
1322
+ IsObject(stableInput) ? Object.values(stableInput) : stableInput
2186
1323
  );
2187
- const inputKey = urls.join("\0");
2188
1324
  useLayoutEffect(() => {
2189
1325
  if (cachedResult) return;
2190
1326
  if (onLoadCalledForRef.current === inputKey) return;
@@ -2211,28 +1347,28 @@ function useTexture(input, optionsOrOnLoad) {
2211
1347
  }, [renderer, loadedTextures, cachedResult]);
2212
1348
  const mappedTextures = useMemo(() => {
2213
1349
  if (cachedResult) return cachedResult;
2214
- if (IsObject(input)) {
1350
+ if (IsObject(stableInput)) {
2215
1351
  const keyed = {};
2216
1352
  const textureArray = loadedTextures;
2217
1353
  let i = 0;
2218
- for (const key in input) keyed[key] = textureArray[i++];
1354
+ for (const key in stableInput) keyed[key] = textureArray[i++];
2219
1355
  return keyed;
2220
1356
  } else {
2221
1357
  return loadedTextures;
2222
1358
  }
2223
- }, [input, loadedTextures, cachedResult]);
1359
+ }, [stableInput, loadedTextures, cachedResult]);
2224
1360
  useEffect(() => {
2225
1361
  if (!cache) return;
2226
1362
  const urlTextureMap = [];
2227
- if (typeof input === "string") {
2228
- urlTextureMap.push([input, mappedTextures]);
2229
- } else if (Array.isArray(input)) {
1363
+ if (typeof stableInput === "string") {
1364
+ urlTextureMap.push([stableInput, mappedTextures]);
1365
+ } else if (Array.isArray(stableInput)) {
2230
1366
  const textureArray = mappedTextures;
2231
- input.forEach((url, i) => urlTextureMap.push([url, textureArray[i]]));
2232
- } else if (IsObject(input)) {
1367
+ stableInput.forEach((url, i) => urlTextureMap.push([url, textureArray[i]]));
1368
+ } else if (IsObject(stableInput)) {
2233
1369
  const textureRecord = mappedTextures;
2234
- for (const key in input) {
2235
- const url = input[key];
1370
+ for (const key in stableInput) {
1371
+ const url = stableInput[key];
2236
1372
  urlTextureMap.push([url, textureRecord[key]]);
2237
1373
  }
2238
1374
  }
@@ -2261,7 +1397,7 @@ function useTexture(input, optionsOrOnLoad) {
2261
1397
  }
2262
1398
  return { _textureRefs: refs };
2263
1399
  });
2264
- }, [cache, input, mappedTextures, store]);
1400
+ }, [cache, stableInput, mappedTextures, store]);
2265
1401
  return mappedTextures;
2266
1402
  }
2267
1403
  useTexture.preload = (url) => useLoader.preload(TextureLoader, url);
@@ -2356,13 +1492,133 @@ function useRenderTarget(widthOrOptions, heightOrOptions, options) {
2356
1492
  height = widthOrOptions;
2357
1493
  }
2358
1494
  }
2359
- return useMemo(() => {
2360
- const w = width ?? size.width;
2361
- const h = height ?? size.height;
2362
- {
2363
- return isLegacy ? new WebGLRenderTarget(w, h, opts) : new RenderTarget(w, h, opts);
2364
- }
2365
- }, [width, height, size.width, size.height, opts, isLegacy]);
1495
+ return useMemo(() => {
1496
+ const w = width ?? size.width;
1497
+ const h = height ?? size.height;
1498
+ {
1499
+ return isLegacy ? new WebGLRenderTarget(w, h, opts) : new RenderTarget(w, h, opts);
1500
+ }
1501
+ }, [width, height, size.width, size.height, opts, isLegacy]);
1502
+ }
1503
+
1504
+ const presetsObj = {
1505
+ apartment: "lebombo_1k.hdr",
1506
+ city: "potsdamer_platz_1k.hdr",
1507
+ dawn: "kiara_1_dawn_1k.hdr",
1508
+ forest: "forest_slope_1k.hdr",
1509
+ lobby: "st_fagans_interior_1k.hdr",
1510
+ night: "dikhololo_night_1k.hdr",
1511
+ park: "rooitou_park_1k.hdr",
1512
+ studio: "studio_small_03_1k.hdr",
1513
+ sunset: "venice_sunset_1k.hdr",
1514
+ warehouse: "empty_warehouse_01_1k.hdr"
1515
+ };
1516
+
1517
+ const CUBEMAP_ROOT = "https://raw.githack.com/pmndrs/drei-assets/456060a26bbeb8fdf79326f224b6d99b8bcce736/hdri/";
1518
+ const isArray = (arr) => Array.isArray(arr);
1519
+ const defaultFiles = ["/px.png", "/nx.png", "/py.png", "/ny.png", "/pz.png", "/nz.png"];
1520
+ function useEnvironment({
1521
+ files = defaultFiles,
1522
+ path = "",
1523
+ preset = void 0,
1524
+ colorSpace = void 0,
1525
+ extensions
1526
+ } = {}) {
1527
+ if (preset) {
1528
+ validatePreset(preset);
1529
+ files = presetsObj[preset];
1530
+ path = CUBEMAP_ROOT;
1531
+ }
1532
+ const multiFile = isArray(files);
1533
+ const { extension, isCubemap } = getExtension(files);
1534
+ const loader = getLoader(extension);
1535
+ if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
1536
+ const renderer = useThree((state) => state.renderer);
1537
+ useLayoutEffect(() => {
1538
+ if (extension !== "webp" && extension !== "jpg" && extension !== "jpeg") return;
1539
+ function clearGainmapTexture() {
1540
+ useLoader.clear(loader, multiFile ? [files] : files);
1541
+ }
1542
+ renderer.domElement.addEventListener("webglcontextlost", clearGainmapTexture, { once: true });
1543
+ }, [extension, files, loader, multiFile, renderer.domElement]);
1544
+ const loaderResult = useLoader(
1545
+ loader,
1546
+ multiFile ? [files] : files,
1547
+ (loader2) => {
1548
+ if (extension === "webp" || extension === "jpg" || extension === "jpeg") {
1549
+ loader2.setRenderer?.(renderer);
1550
+ }
1551
+ loader2.setPath?.(path);
1552
+ if (extensions) extensions(loader2);
1553
+ }
1554
+ );
1555
+ let texture = multiFile ? (
1556
+ // @ts-ignore
1557
+ loaderResult[0]
1558
+ ) : loaderResult;
1559
+ if (extension === "jpg" || extension === "jpeg" || extension === "webp") {
1560
+ texture = texture.renderTarget?.texture;
1561
+ }
1562
+ texture.mapping = isCubemap ? CubeReflectionMapping : EquirectangularReflectionMapping;
1563
+ texture.colorSpace = colorSpace ?? (isCubemap ? "srgb" : "srgb-linear");
1564
+ return texture;
1565
+ }
1566
+ const preloadDefaultOptions = {
1567
+ files: defaultFiles,
1568
+ path: "",
1569
+ preset: void 0,
1570
+ extensions: void 0
1571
+ };
1572
+ useEnvironment.preload = (preloadOptions) => {
1573
+ const options = { ...preloadDefaultOptions, ...preloadOptions };
1574
+ let { files, path = "" } = options;
1575
+ const { preset, extensions } = options;
1576
+ if (preset) {
1577
+ validatePreset(preset);
1578
+ files = presetsObj[preset];
1579
+ path = CUBEMAP_ROOT;
1580
+ }
1581
+ const { extension } = getExtension(files);
1582
+ if (extension === "webp" || extension === "jpg" || extension === "jpeg") {
1583
+ throw new Error("useEnvironment: Preloading gainmaps is not supported");
1584
+ }
1585
+ const loader = getLoader(extension);
1586
+ if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
1587
+ useLoader.preload(loader, isArray(files) ? [files] : files, (loader2) => {
1588
+ loader2.setPath?.(path);
1589
+ if (extensions) extensions(loader2);
1590
+ });
1591
+ };
1592
+ const clearDefaultOptins = {
1593
+ files: defaultFiles,
1594
+ preset: void 0
1595
+ };
1596
+ useEnvironment.clear = (clearOptions) => {
1597
+ const options = { ...clearDefaultOptins, ...clearOptions };
1598
+ let { files } = options;
1599
+ const { preset } = options;
1600
+ if (preset) {
1601
+ validatePreset(preset);
1602
+ files = presetsObj[preset];
1603
+ }
1604
+ const { extension } = getExtension(files);
1605
+ const loader = getLoader(extension);
1606
+ if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
1607
+ useLoader.clear(loader, isArray(files) ? [files] : files);
1608
+ };
1609
+ function validatePreset(preset) {
1610
+ if (!(preset in presetsObj)) throw new Error("Preset must be one of: " + Object.keys(presetsObj).join(", "));
1611
+ }
1612
+ function getExtension(files) {
1613
+ const isCubemap = isArray(files) && files.length === 6;
1614
+ const isGainmap = isArray(files) && files.length === 3 && files.some((file) => file.endsWith("json"));
1615
+ const firstEntry = isArray(files) ? files[0] : files;
1616
+ const extension = isCubemap ? "cube" : isGainmap ? "webp" : firstEntry.startsWith("data:application/exr") ? "exr" : firstEntry.startsWith("data:application/hdr") ? "hdr" : firstEntry.startsWith("data:image/jpeg") ? "jpg" : firstEntry.split(".").pop()?.split("?")?.shift()?.toLowerCase();
1617
+ return { extension, isCubemap, isGainmap };
1618
+ }
1619
+ function getLoader(extension) {
1620
+ const loader = extension === "cube" ? CubeTextureLoader : extension === "hdr" ? HDRLoader : extension === "exr" ? EXRLoader : extension === "jpg" || extension === "jpeg" ? UltraHDRLoader : extension === "webp" ? GainMapLoader : null;
1621
+ return loader;
2366
1622
  }
2367
1623
 
2368
1624
  function useStore() {
@@ -2382,6 +1638,8 @@ function useGraph(object) {
2382
1638
  return useMemo(() => buildGraph(object), [object]);
2383
1639
  }
2384
1640
 
1641
+ const t = 1, o = 8, r = 32, e = 2, i$1 = 268435456;
1642
+
2385
1643
  let effectId = 0;
2386
1644
  function addEffect(callback) {
2387
1645
  notifyDepreciated({
@@ -13280,399 +12538,982 @@ Check the top-level render call using <` + i + ">.");
13280
12538
  var o = x.H;
13281
12539
  x.H = $o;
13282
12540
  try {
13283
- return Vi(e, n);
13284
- } finally {
13285
- x.H = o;
12541
+ return Vi(e, n);
12542
+ } finally {
12543
+ x.H = o;
12544
+ }
12545
+ }, useReducer: function(e, n, o) {
12546
+ z = "useReducer", D(), N();
12547
+ var i = x.H;
12548
+ x.H = $o;
12549
+ try {
12550
+ return Br(e, n, o);
12551
+ } finally {
12552
+ x.H = i;
12553
+ }
12554
+ }, useRef: function() {
12555
+ return z = "useRef", D(), N(), xe().memoizedState;
12556
+ }, useState: function() {
12557
+ z = "useState", D(), N();
12558
+ var e = x.H;
12559
+ x.H = $o;
12560
+ try {
12561
+ return Br(gr);
12562
+ } finally {
12563
+ x.H = e;
12564
+ }
12565
+ }, useDebugValue: function() {
12566
+ z = "useDebugValue", D(), N();
12567
+ }, useDeferredValue: function(e, n) {
12568
+ return z = "useDeferredValue", D(), N(), nc(e, n);
12569
+ }, useTransition: function() {
12570
+ return z = "useTransition", D(), N(), Qp();
12571
+ }, useSyncExternalStore: function(e, n, o) {
12572
+ return z = "useSyncExternalStore", D(), N(), ta(e, n, o);
12573
+ }, useId: function() {
12574
+ return z = "useId", D(), N(), xe().memoizedState;
12575
+ }, useFormState: function(e) {
12576
+ return z = "useFormState", D(), N(), hs(e);
12577
+ }, useActionState: function(e) {
12578
+ return z = "useActionState", D(), N(), hs(e);
12579
+ }, useOptimistic: function(e, n) {
12580
+ return z = "useOptimistic", D(), N(), rf(e, n);
12581
+ }, useMemoCache: function(e) {
12582
+ return D(), Oa(e);
12583
+ }, useHostTransitionStatus: ia, useCacheRefresh: function() {
12584
+ return z = "useCacheRefresh", N(), xe().memoizedState;
12585
+ }, useEffectEvent: function(e) {
12586
+ return z = "useEffectEvent", D(), N(), oa(e);
12587
+ } }, dm = { readContext: function(e) {
12588
+ return Ce(), Ee(e);
12589
+ }, use: function(e) {
12590
+ return D(), we(e);
12591
+ }, useCallback: function(e, n) {
12592
+ return z = "useCallback", D(), N(), Ma(e, n);
12593
+ }, useContext: function(e) {
12594
+ return z = "useContext", D(), N(), Ee(e);
12595
+ }, useEffect: function(e, n) {
12596
+ z = "useEffect", D(), N(), Qn(2048, Ut, e, n);
12597
+ }, useImperativeHandle: function(e, n, o) {
12598
+ return z = "useImperativeHandle", D(), N(), aa(e, n, o);
12599
+ }, useInsertionEffect: function(e, n) {
12600
+ return z = "useInsertionEffect", D(), N(), Qn(4, Wt, e, n);
12601
+ }, useLayoutEffect: function(e, n) {
12602
+ return z = "useLayoutEffect", D(), N(), Qn(4, Rr, e, n);
12603
+ }, useMemo: function(e, n) {
12604
+ z = "useMemo", D(), N();
12605
+ var o = x.H;
12606
+ x.H = $o;
12607
+ try {
12608
+ return Vi(e, n);
12609
+ } finally {
12610
+ x.H = o;
12611
+ }
12612
+ }, useReducer: function(e, n, o) {
12613
+ z = "useReducer", D(), N();
12614
+ var i = x.H;
12615
+ x.H = $o;
12616
+ try {
12617
+ return Qi(e, n, o);
12618
+ } finally {
12619
+ x.H = i;
12620
+ }
12621
+ }, useRef: function() {
12622
+ return z = "useRef", D(), N(), xe().memoizedState;
12623
+ }, useState: function() {
12624
+ z = "useState", D(), N();
12625
+ var e = x.H;
12626
+ x.H = $o;
12627
+ try {
12628
+ return Qi(gr);
12629
+ } finally {
12630
+ x.H = e;
12631
+ }
12632
+ }, useDebugValue: function() {
12633
+ z = "useDebugValue", D(), N();
12634
+ }, useDeferredValue: function(e, n) {
12635
+ return z = "useDeferredValue", D(), N(), sf(e, n);
12636
+ }, useTransition: function() {
12637
+ return z = "useTransition", D(), N(), Ro();
12638
+ }, useSyncExternalStore: function(e, n, o) {
12639
+ return z = "useSyncExternalStore", D(), N(), ta(e, n, o);
12640
+ }, useId: function() {
12641
+ return z = "useId", D(), N(), xe().memoizedState;
12642
+ }, useFormState: function(e) {
12643
+ return z = "useFormState", D(), N(), $t(e);
12644
+ }, useActionState: function(e) {
12645
+ return z = "useActionState", D(), N(), $t(e);
12646
+ }, useOptimistic: function(e, n) {
12647
+ return z = "useOptimistic", D(), N(), of(e, n);
12648
+ }, useMemoCache: function(e) {
12649
+ return D(), Oa(e);
12650
+ }, useHostTransitionStatus: ia, useCacheRefresh: function() {
12651
+ return z = "useCacheRefresh", N(), xe().memoizedState;
12652
+ }, useEffectEvent: function(e) {
12653
+ return z = "useEffectEvent", D(), N(), oa(e);
12654
+ } };
12655
+ var Fy = {}, Hy = /* @__PURE__ */ new Set(), Ay = /* @__PURE__ */ new Set(), jy = /* @__PURE__ */ new Set(), Dy = /* @__PURE__ */ new Set(), Wy = /* @__PURE__ */ new Set(), Uy = /* @__PURE__ */ new Set(), By = /* @__PURE__ */ new Set(), Oy = /* @__PURE__ */ new Set(), My = /* @__PURE__ */ new Set(), Qy = /* @__PURE__ */ new Set();
12656
+ Object.freeze(Fy);
12657
+ var zg = { enqueueSetState: function(e, n, o) {
12658
+ e = e._reactInternals;
12659
+ var i = Nt(e), s = zo(i);
12660
+ s.payload = n, o != null && (df(o), s.callback = o), n = Mt(e, s, i), n !== null && (ur(i, "this.setState()", e), We(n, e, i), Bi(n, e, i));
12661
+ }, enqueueReplaceState: function(e, n, o) {
12662
+ e = e._reactInternals;
12663
+ var i = Nt(e), s = zo(i);
12664
+ s.tag = Cy, s.payload = n, o != null && (df(o), s.callback = o), n = Mt(e, s, i), n !== null && (ur(i, "this.replaceState()", e), We(n, e, i), Bi(n, e, i));
12665
+ }, enqueueForceUpdate: function(e, n) {
12666
+ e = e._reactInternals;
12667
+ var o = Nt(e), i = zo(o);
12668
+ i.tag = Ty, n != null && (df(n), i.callback = n), n = Mt(e, i, o), n !== null && (ur(o, "this.forceUpdate()", e), We(n, e, o), Bi(n, e, o));
12669
+ } }, bd = null, Cg = null, Tg = Error("This is not a real error. It's an implementation detail of React's selective hydration feature. If this leaks into userspace, it's a bug in React. Please file an issue."), Cn = false, $y = {}, Vy = {}, qy = {}, Gy = {}, vd = false, Jy = {}, fm = {}, _g = { dehydrated: null, treeContext: null, retryLane: 0, hydrationErrors: null }, Zy = false, Yy = null;
12670
+ Yy = /* @__PURE__ */ new Set();
12671
+ var Si = false, Tn = false, Rg = false, Xy = typeof WeakSet == "function" ? WeakSet : Set, Gn = null, Sd = null, kd = null, _n = null, nr = false, Vo = null, Wn = false, wd = 8192, Vb = { getCacheForType: function(e) {
12672
+ var n = Ee(un), o = n.data.get(e);
12673
+ return o === void 0 && (o = e(), n.data.set(e, o)), o;
12674
+ }, cacheSignal: function() {
12675
+ return Ee(un).controller.signal;
12676
+ }, getOwner: function() {
12677
+ return di;
12678
+ } }, pm = 0, hm = 1, mm = 2, gm = 3, ym = 4;
12679
+ if (typeof Symbol == "function" && Symbol.for) {
12680
+ var bp = Symbol.for;
12681
+ pm = bp("selector.component"), hm = bp("selector.has_pseudo_class"), mm = bp("selector.role"), gm = bp("selector.test_id"), ym = bp("selector.text");
12682
+ }
12683
+ var bm = [], qb = typeof WeakMap == "function" ? WeakMap : Map, Jn = 0, Zn = 2, uo = 4, ki = 0, vp = 1, iu = 2, vm = 3, Tl = 4, Sm = 6, Ky = 5, ye = Jn, je = null, se = null, ae = 0, tr = 0, km = 1, lu = 2, Sp = 3, eb = 4, Eg = 5, kp = 6, wm = 7, Ig = 8, su = 9, Le = tr, Er = null, _l = false, Pd = false, Lg = false, Ta = 0, nn = ki, Rl = 0, El = 0, Ng = 0, rr = 0, uu = 0, wp = null, Bt = null, Pm = false, xm = 0, nb = 0, tb = 300, Pp = 1 / 0, Fg = 500, xp = null, gn = null, Il = null, zm = 0, Hg = 1, Ag = 2, rb = 3, Ll = 0, ob = 1, ab = 2, ib = 3, lb = 4, Cm = 5, Rn = 0, Nl = null, xd = null, qo = 0, jg = 0, Dg = -0, Wg = null, sb = null, ub = null, Go = zm, cb = null, Gb = 50, zp = 0, Ug = null, Bg = false, Tm = false, Jb = 50, cu = 0, Cp = null, zd = false, _m = null, db = false, fb = /* @__PURE__ */ new Set(), Zb = {}, co = null, Cd = null, pb = false;
12684
+ try {
12685
+ var o0 = Object.preventExtensions({});
12686
+ } catch {
12687
+ pb = true;
12688
+ }
12689
+ var hb = false, mb = {}, gb = null, yb = null, bb = null, vb = null, Sb = null, kb = null, wb = null, Pb = null, xb = null, zb = null;
12690
+ return gb = function(e, n, o, i) {
12691
+ n = Yn(e, n), n !== null && (o = _d(n.memoizedState, o, 0, i), n.memoizedState = o, n.baseState = o, e.memoizedProps = ze({}, e.memoizedProps), o = On(e, 2), o !== null && We(o, e, 2));
12692
+ }, yb = function(e, n, o) {
12693
+ n = Yn(e, n), n !== null && (o = du(n.memoizedState, o, 0), n.memoizedState = o, n.baseState = o, e.memoizedProps = ze({}, e.memoizedProps), o = On(e, 2), o !== null && We(o, e, 2));
12694
+ }, bb = function(e, n, o, i) {
12695
+ n = Yn(e, n), n !== null && (o = F(n.memoizedState, o, i), n.memoizedState = o, n.baseState = o, e.memoizedProps = ze({}, e.memoizedProps), o = On(e, 2), o !== null && We(o, e, 2));
12696
+ }, vb = function(e, n, o) {
12697
+ e.pendingProps = _d(e.memoizedProps, n, 0, o), e.alternate && (e.alternate.pendingProps = e.pendingProps), n = On(e, 2), n !== null && We(n, e, 2);
12698
+ }, Sb = function(e, n) {
12699
+ e.pendingProps = du(e.memoizedProps, n, 0), e.alternate && (e.alternate.pendingProps = e.pendingProps), n = On(e, 2), n !== null && We(n, e, 2);
12700
+ }, kb = function(e, n, o) {
12701
+ e.pendingProps = F(e.memoizedProps, n, o), e.alternate && (e.alternate.pendingProps = e.pendingProps), n = On(e, 2), n !== null && We(n, e, 2);
12702
+ }, wb = function(e) {
12703
+ var n = On(e, 2);
12704
+ n !== null && We(n, e, 2);
12705
+ }, Pb = function(e) {
12706
+ var n = ut(), o = On(e, n);
12707
+ o !== null && We(o, e, n);
12708
+ }, xb = function(e) {
12709
+ pu = e;
12710
+ }, zb = function(e) {
12711
+ fu = e;
12712
+ }, le.attemptContinuousHydration = function(e) {
12713
+ if (e.tag === 13 || e.tag === 31) {
12714
+ var n = On(e, 67108864);
12715
+ n !== null && We(n, e, 67108864), rl(e, 67108864);
12716
+ }
12717
+ }, le.attemptHydrationAtCurrentPriority = function(e) {
12718
+ if (e.tag === 13 || e.tag === 31) {
12719
+ var n = Nt(e);
12720
+ n = Xo(n);
12721
+ var o = On(e, n);
12722
+ o !== null && We(o, e, n), rl(e, n);
12723
+ }
12724
+ }, le.attemptSynchronousHydration = function(e) {
12725
+ switch (e.tag) {
12726
+ case 3:
12727
+ if (e = e.stateNode, e.current.memoizedState.isDehydrated) {
12728
+ var n = _t(e.pendingLanes);
12729
+ if (n !== 0) {
12730
+ for (e.pendingLanes |= 2, e.entangledLanes |= 2; n; ) {
12731
+ var o = 1 << 31 - vn(n);
12732
+ e.entanglements[1] |= o, n &= ~o;
12733
+ }
12734
+ Kn(e), (ye & (Zn | uo)) === Jn && (Pp = me() + Fg, Wa(0));
12735
+ }
12736
+ }
12737
+ break;
12738
+ case 31:
12739
+ case 13:
12740
+ n = On(e, 2), n !== null && We(n, e, 2), Ls(), rl(e, 2);
12741
+ }
12742
+ }, le.batchedUpdates = function(e, n) {
12743
+ return e(n);
12744
+ }, le.createComponentSelector = function(e) {
12745
+ return { $$typeof: pm, value: e };
12746
+ }, le.createContainer = function(e, n, o, i, s, u, f, p, g, S) {
12747
+ return Ka(e, n, false, null, o, i, u, null, f, p, g, S);
12748
+ }, le.createHasPseudoClassSelector = function(e) {
12749
+ return { $$typeof: hm, value: e };
12750
+ }, le.createHydrationContainer = function(e, n, o, i, s, u, f, p, g, S, T, _, I, O) {
12751
+ return e = Ka(o, i, true, e, s, u, p, O, g, S, T, _), e.context = Dh(null), o = e.current, i = Nt(o), i = Xo(i), s = zo(i), s.callback = n ?? null, Mt(o, s, i), ur(i, "hydrateRoot()", null), n = i, e.current.lanes = n, Ci(e, n), Kn(e), e;
12752
+ }, le.createPortal = function(e, n, o) {
12753
+ var i = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
12754
+ try {
12755
+ vt(i);
12756
+ var s = false;
12757
+ } catch {
12758
+ s = true;
13286
12759
  }
13287
- }, useReducer: function(e, n, o) {
13288
- z = "useReducer", D(), N();
13289
- var i = x.H;
13290
- x.H = $o;
12760
+ return s && (console.error("The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", typeof Symbol == "function" && Symbol.toStringTag && i[Symbol.toStringTag] || i.constructor.name || "Object"), vt(i)), { $$typeof: Ao, key: i == null ? null : "" + i, children: e, containerInfo: n, implementation: o };
12761
+ }, le.createRoleSelector = function(e) {
12762
+ return { $$typeof: mm, value: e };
12763
+ }, le.createTestNameSelector = function(e) {
12764
+ return { $$typeof: gm, value: e };
12765
+ }, le.createTextSelector = function(e) {
12766
+ return { $$typeof: ym, value: e };
12767
+ }, le.defaultOnCaughtError = function(e) {
12768
+ var n = bd ? "The above error occurred in the <" + bd + "> component." : "The above error occurred in one of your React components.", o = "React will try to recreate this component tree from scratch using the error boundary you provided, " + ((Cg || "Anonymous") + ".");
12769
+ typeof e == "object" && e !== null && typeof e.environmentName == "string" ? ri("error", [`%o
12770
+
12771
+ %s
12772
+
12773
+ %s
12774
+ `, e, n, o], e.environmentName)() : console.error(`%o
12775
+
12776
+ %s
12777
+
12778
+ %s
12779
+ `, e, n, o);
12780
+ }, le.defaultOnRecoverableError = function(e) {
12781
+ qg(e);
12782
+ }, le.defaultOnUncaughtError = function(e) {
12783
+ qg(e), console.warn(`%s
12784
+
12785
+ %s
12786
+ `, bd ? "An error occurred in the <" + bd + "> component." : "An error occurred in one of your React components.", `Consider adding an error boundary to your tree to customize error handling behavior.
12787
+ Visit https://react.dev/link/error-boundaries to learn more about error boundaries.`);
12788
+ }, le.deferredUpdates = function(e) {
12789
+ var n = x.T, o = wt();
13291
12790
  try {
13292
- return Br(e, n, o);
12791
+ return an(32), x.T = null, e();
13293
12792
  } finally {
13294
- x.H = i;
12793
+ an(o), x.T = n;
13295
12794
  }
13296
- }, useRef: function() {
13297
- return z = "useRef", D(), N(), xe().memoizedState;
13298
- }, useState: function() {
13299
- z = "useState", D(), N();
13300
- var e = x.H;
13301
- x.H = $o;
12795
+ }, le.discreteUpdates = function(e, n, o, i, s) {
12796
+ var u = x.T, f = wt();
13302
12797
  try {
13303
- return Br(gr);
12798
+ return an(2), x.T = null, e(n, o, i, s);
13304
12799
  } finally {
13305
- x.H = e;
12800
+ an(f), x.T = u, ye === Jn && (Pp = me() + Fg);
13306
12801
  }
13307
- }, useDebugValue: function() {
13308
- z = "useDebugValue", D(), N();
13309
- }, useDeferredValue: function(e, n) {
13310
- return z = "useDeferredValue", D(), N(), nc(e, n);
13311
- }, useTransition: function() {
13312
- return z = "useTransition", D(), N(), Qp();
13313
- }, useSyncExternalStore: function(e, n, o) {
13314
- return z = "useSyncExternalStore", D(), N(), ta(e, n, o);
13315
- }, useId: function() {
13316
- return z = "useId", D(), N(), xe().memoizedState;
13317
- }, useFormState: function(e) {
13318
- return z = "useFormState", D(), N(), hs(e);
13319
- }, useActionState: function(e) {
13320
- return z = "useActionState", D(), N(), hs(e);
13321
- }, useOptimistic: function(e, n) {
13322
- return z = "useOptimistic", D(), N(), rf(e, n);
13323
- }, useMemoCache: function(e) {
13324
- return D(), Oa(e);
13325
- }, useHostTransitionStatus: ia, useCacheRefresh: function() {
13326
- return z = "useCacheRefresh", N(), xe().memoizedState;
13327
- }, useEffectEvent: function(e) {
13328
- return z = "useEffectEvent", D(), N(), oa(e);
13329
- } }, dm = { readContext: function(e) {
13330
- return Ce(), Ee(e);
13331
- }, use: function(e) {
13332
- return D(), we(e);
13333
- }, useCallback: function(e, n) {
13334
- return z = "useCallback", D(), N(), Ma(e, n);
13335
- }, useContext: function(e) {
13336
- return z = "useContext", D(), N(), Ee(e);
13337
- }, useEffect: function(e, n) {
13338
- z = "useEffect", D(), N(), Qn(2048, Ut, e, n);
13339
- }, useImperativeHandle: function(e, n, o) {
13340
- return z = "useImperativeHandle", D(), N(), aa(e, n, o);
13341
- }, useInsertionEffect: function(e, n) {
13342
- return z = "useInsertionEffect", D(), N(), Qn(4, Wt, e, n);
13343
- }, useLayoutEffect: function(e, n) {
13344
- return z = "useLayoutEffect", D(), N(), Qn(4, Rr, e, n);
13345
- }, useMemo: function(e, n) {
13346
- z = "useMemo", D(), N();
13347
- var o = x.H;
13348
- x.H = $o;
13349
- try {
13350
- return Vi(e, n);
13351
- } finally {
13352
- x.H = o;
12802
+ }, le.findAllNodes = kc, le.findBoundingRects = function(e, n) {
12803
+ if (!xr) throw Error("Test selector API is not supported by this renderer.");
12804
+ n = kc(e, n), e = [];
12805
+ for (var o = 0; o < n.length; o++) e.push(ma(n[o]));
12806
+ for (n = e.length - 1; 0 < n; n--) {
12807
+ o = e[n];
12808
+ for (var i = o.x, s = i + o.width, u = o.y, f = u + o.height, p = n - 1; 0 <= p; p--) if (n !== p) {
12809
+ var g = e[p], S = g.x, T = S + g.width, _ = g.y, I = _ + g.height;
12810
+ if (i >= S && u >= _ && s <= T && f <= I) {
12811
+ e.splice(n, 1);
12812
+ break;
12813
+ } else if (i !== S || o.width !== g.width || I < u || _ > f) {
12814
+ if (!(u !== _ || o.height !== g.height || T < i || S > s)) {
12815
+ S > i && (g.width += S - i, g.x = i), T < s && (g.width = s - S), e.splice(n, 1);
12816
+ break;
12817
+ }
12818
+ } else {
12819
+ _ > u && (g.height += _ - u, g.y = u), I < f && (g.height = f - _), e.splice(n, 1);
12820
+ break;
12821
+ }
12822
+ }
13353
12823
  }
13354
- }, useReducer: function(e, n, o) {
13355
- z = "useReducer", D(), N();
13356
- var i = x.H;
13357
- x.H = $o;
13358
- try {
13359
- return Qi(e, n, o);
13360
- } finally {
13361
- x.H = i;
12824
+ return e;
12825
+ }, le.findHostInstance = function(e) {
12826
+ var n = e._reactInternals;
12827
+ if (n === void 0) throw typeof e.render == "function" ? Error("Unable to find node on an unmounted component.") : (e = Object.keys(e).join(","), Error("Argument appears to not be a ReactComponent. Keys: " + e));
12828
+ return e = mu(n), e === null ? null : ot(e.stateNode);
12829
+ }, le.findHostInstanceWithNoPortals = function(e) {
12830
+ return e = Ed(e), e = e !== null ? _p(e) : null, e === null ? null : ot(e.stateNode);
12831
+ }, le.findHostInstanceWithWarning = function(e, n) {
12832
+ var o = e._reactInternals;
12833
+ if (o === void 0) throw typeof e.render == "function" ? Error("Unable to find node on an unmounted component.") : (e = Object.keys(e).join(","), Error("Argument appears to not be a ReactComponent. Keys: " + e));
12834
+ if (e = mu(o), e === null) return null;
12835
+ if (e.mode & 8) {
12836
+ var i = G(o) || "Component";
12837
+ mb[i] || (mb[i] = true, B(e, function() {
12838
+ o.mode & 8 ? console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which is inside StrictMode. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", n, n, i) : console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which renders StrictMode children. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", n, n, i);
12839
+ }));
13362
12840
  }
13363
- }, useRef: function() {
13364
- return z = "useRef", D(), N(), xe().memoizedState;
13365
- }, useState: function() {
13366
- z = "useState", D(), N();
13367
- var e = x.H;
13368
- x.H = $o;
12841
+ return ot(e.stateNode);
12842
+ }, le.flushPassiveEffects = el, le.flushSyncFromReconciler = function(e) {
12843
+ var n = ye;
12844
+ ye |= 1;
12845
+ var o = x.T, i = wt();
13369
12846
  try {
13370
- return Qi(gr);
12847
+ if (an(2), x.T = null, e) return e();
13371
12848
  } finally {
13372
- x.H = e;
12849
+ an(i), x.T = o, ye = n, (ye & (Zn | uo)) === Jn && Wa(0);
12850
+ }
12851
+ }, le.flushSyncWork = Ls, le.focusWithin = function(e, n) {
12852
+ if (!xr) throw Error("Test selector API is not supported by this renderer.");
12853
+ for (e = Ef(e), n = hh(e, n), n = Array.from(n), e = 0; e < n.length; ) {
12854
+ var o = n[e++], i = o.tag;
12855
+ if (!Kr(o)) {
12856
+ if ((i === 5 || i === 26 || i === 27) && Ft(o.stateNode)) return true;
12857
+ for (o = o.child; o !== null; ) n.push(o), o = o.sibling;
12858
+ }
12859
+ }
12860
+ return false;
12861
+ }, le.getFindAllNodesFailureDescription = function(e, n) {
12862
+ if (!xr) throw Error("Test selector API is not supported by this renderer.");
12863
+ var o = 0, i = [];
12864
+ e = [Ef(e), 0];
12865
+ for (var s = 0; s < e.length; ) {
12866
+ var u = e[s++], f = u.tag, p = e[s++], g = n[p];
12867
+ if ((f !== 5 && f !== 26 && f !== 27 || !Kr(u)) && (If(u, g) && (i.push(Sc(g)), p++, p > o && (o = p)), p < n.length)) for (u = u.child; u !== null; ) e.push(u, p), u = u.sibling;
12868
+ }
12869
+ if (o < n.length) {
12870
+ for (e = []; o < n.length; o++) e.push(Sc(n[o]));
12871
+ return `findAllNodes was able to match part of the selector:
12872
+ ` + (i.join(" > ") + `
12873
+
12874
+ No matching component was found for:
12875
+ `) + e.join(" > ");
12876
+ }
12877
+ return null;
12878
+ }, le.getPublicRootInstance = function(e) {
12879
+ if (e = e.current, !e.child) return null;
12880
+ switch (e.child.tag) {
12881
+ case 27:
12882
+ case 5:
12883
+ return ot(e.child.stateNode);
12884
+ default:
12885
+ return e.child.stateNode;
12886
+ }
12887
+ }, le.injectIntoDevTools = function() {
12888
+ var e = { bundleType: 1, version: Jt, rendererPackageName: Zt, currentDispatcherRef: x, reconcilerVersion: "19.2.0" };
12889
+ return jo !== null && (e.rendererConfig = jo), e.overrideHookState = gb, e.overrideHookStateDeletePath = yb, e.overrideHookStateRenamePath = bb, e.overrideProps = vb, e.overridePropsDeletePath = Sb, e.overridePropsRenamePath = kb, e.scheduleUpdate = wb, e.scheduleRetry = Pb, e.setErrorHandler = xb, e.setSuspenseHandler = zb, e.scheduleRefresh = hu, e.scheduleRoot = Fl, e.setRefreshHandler = Ir, e.getCurrentFiber = Ic, Ep(e);
12890
+ }, le.isAlreadyRendering = Ns, le.observeVisibleRects = function(e, n, o, i) {
12891
+ function s() {
12892
+ var S = kc(e, n);
12893
+ u.forEach(function(T) {
12894
+ 0 > S.indexOf(T) && g(T);
12895
+ }), S.forEach(function(T) {
12896
+ 0 > u.indexOf(T) && p(T);
12897
+ });
12898
+ }
12899
+ if (!xr) throw Error("Test selector API is not supported by this renderer.");
12900
+ var u = kc(e, n);
12901
+ o = zr(u, o, i);
12902
+ var f = o.disconnect, p = o.observe, g = o.unobserve;
12903
+ return bm.push(s), { disconnect: function() {
12904
+ var S = bm.indexOf(s);
12905
+ 0 <= S && bm.splice(S, 1), f();
12906
+ } };
12907
+ }, le.shouldError = function(e) {
12908
+ return pu(e);
12909
+ }, le.shouldSuspend = function(e) {
12910
+ return fu(e);
12911
+ }, le.startHostTransition = function(e, n, o, i) {
12912
+ if (e.tag !== 5) throw Error("Expected the form instance to be a HostComponent. This is a bug in React.");
12913
+ var s = uf(e).queue;
12914
+ Hp(e), nt(e, s, n, Xt, o === null ? Em : function() {
12915
+ x.T === null && console.error("requestFormReset was called outside a transition or action. To fix, move to an action, or wrap with startTransition.");
12916
+ var u = uf(e);
12917
+ return u.next === null && (u = e.alternate.memoizedState), qi(e, u.next.queue, {}, Nt(e)), o(i);
12918
+ });
12919
+ }, le.updateContainer = function(e, n, o, i) {
12920
+ var s = n.current, u = Nt(s);
12921
+ return As(s, u, e, n, o, i), u;
12922
+ }, le.updateContainerSync = Wh, le;
12923
+ }, Tt.exports.default = Tt.exports, Object.defineProperty(Tt.exports, "__esModule", { value: true }));
12924
+ })(Mg)), Mg.exports;
12925
+ }
12926
+ var Eb;
12927
+ function n0() {
12928
+ return Eb || (Eb = 1, process.env.NODE_ENV === "production" ? Rm.exports = Kb() : Rm.exports = e0()), Rm.exports;
12929
+ }
12930
+ var t0 = n0();
12931
+ const r0 = Xb(t0);
12932
+
12933
+ const DEFAULT_POINTER_ID = 0;
12934
+ const XR_POINTER_ID_START = 1e3;
12935
+ function getPointerState(internal, pointerId) {
12936
+ let state = internal.pointerMap.get(pointerId);
12937
+ if (!state) {
12938
+ state = {
12939
+ hovered: /* @__PURE__ */ new Map(),
12940
+ captured: /* @__PURE__ */ new Map(),
12941
+ initialClick: [0, 0],
12942
+ initialHits: []
12943
+ };
12944
+ internal.pointerMap.set(pointerId, state);
12945
+ }
12946
+ return state;
12947
+ }
12948
+ function getPointerId(event) {
12949
+ return "pointerId" in event ? event.pointerId : DEFAULT_POINTER_ID;
12950
+ }
12951
+ function makeId(event) {
12952
+ return (event.eventObject || event.object).uuid + "/" + event.index + event.instanceId;
12953
+ }
12954
+ function releaseInternalPointerCapture(internal, obj, pointerId) {
12955
+ const pointerState = internal.pointerMap.get(pointerId);
12956
+ if (!pointerState) return;
12957
+ const captureData = pointerState.captured.get(obj);
12958
+ if (captureData) {
12959
+ pointerState.captured.delete(obj);
12960
+ try {
12961
+ captureData.target.releasePointerCapture?.(pointerId);
12962
+ } catch {
12963
+ }
12964
+ }
12965
+ }
12966
+ function swapInteractivity(store, object, newObject) {
12967
+ const { internal } = store.getState();
12968
+ for (let i = 0; i < internal.interaction.length; i++) {
12969
+ if (internal.interaction[i] === object) internal.interaction[i] = newObject;
12970
+ }
12971
+ for (const pointerState of internal.pointerMap.values()) {
12972
+ for (let i = 0; i < pointerState.initialHits.length; i++) {
12973
+ if (pointerState.initialHits[i] === object) pointerState.initialHits[i] = newObject;
12974
+ }
12975
+ pointerState.hovered.forEach((value, key) => {
12976
+ if (value.eventObject === object || value.object === object) {
12977
+ pointerState.hovered.delete(key);
12978
+ const next = {
12979
+ ...value,
12980
+ eventObject: value.eventObject === object ? newObject : value.eventObject,
12981
+ object: value.object === object ? newObject : value.object
12982
+ };
12983
+ pointerState.hovered.set(makeId(next), next);
12984
+ }
12985
+ });
12986
+ const captureData = pointerState.captured.get(object);
12987
+ if (captureData) {
12988
+ pointerState.captured.delete(object);
12989
+ pointerState.captured.set(newObject, {
12990
+ ...captureData,
12991
+ intersection: {
12992
+ ...captureData.intersection,
12993
+ object: captureData.intersection.object === object ? newObject : captureData.intersection.object,
12994
+ eventObject: captureData.intersection.eventObject === object ? newObject : captureData.intersection.eventObject
13373
12995
  }
13374
- }, useDebugValue: function() {
13375
- z = "useDebugValue", D(), N();
13376
- }, useDeferredValue: function(e, n) {
13377
- return z = "useDeferredValue", D(), N(), sf(e, n);
13378
- }, useTransition: function() {
13379
- return z = "useTransition", D(), N(), Ro();
13380
- }, useSyncExternalStore: function(e, n, o) {
13381
- return z = "useSyncExternalStore", D(), N(), ta(e, n, o);
13382
- }, useId: function() {
13383
- return z = "useId", D(), N(), xe().memoizedState;
13384
- }, useFormState: function(e) {
13385
- return z = "useFormState", D(), N(), $t(e);
13386
- }, useActionState: function(e) {
13387
- return z = "useActionState", D(), N(), $t(e);
13388
- }, useOptimistic: function(e, n) {
13389
- return z = "useOptimistic", D(), N(), of(e, n);
13390
- }, useMemoCache: function(e) {
13391
- return D(), Oa(e);
13392
- }, useHostTransitionStatus: ia, useCacheRefresh: function() {
13393
- return z = "useCacheRefresh", N(), xe().memoizedState;
13394
- }, useEffectEvent: function(e) {
13395
- return z = "useEffectEvent", D(), N(), oa(e);
13396
- } };
13397
- var Fy = {}, Hy = /* @__PURE__ */ new Set(), Ay = /* @__PURE__ */ new Set(), jy = /* @__PURE__ */ new Set(), Dy = /* @__PURE__ */ new Set(), Wy = /* @__PURE__ */ new Set(), Uy = /* @__PURE__ */ new Set(), By = /* @__PURE__ */ new Set(), Oy = /* @__PURE__ */ new Set(), My = /* @__PURE__ */ new Set(), Qy = /* @__PURE__ */ new Set();
13398
- Object.freeze(Fy);
13399
- var zg = { enqueueSetState: function(e, n, o) {
13400
- e = e._reactInternals;
13401
- var i = Nt(e), s = zo(i);
13402
- s.payload = n, o != null && (df(o), s.callback = o), n = Mt(e, s, i), n !== null && (ur(i, "this.setState()", e), We(n, e, i), Bi(n, e, i));
13403
- }, enqueueReplaceState: function(e, n, o) {
13404
- e = e._reactInternals;
13405
- var i = Nt(e), s = zo(i);
13406
- s.tag = Cy, s.payload = n, o != null && (df(o), s.callback = o), n = Mt(e, s, i), n !== null && (ur(i, "this.replaceState()", e), We(n, e, i), Bi(n, e, i));
13407
- }, enqueueForceUpdate: function(e, n) {
13408
- e = e._reactInternals;
13409
- var o = Nt(e), i = zo(o);
13410
- i.tag = Ty, n != null && (df(n), i.callback = n), n = Mt(e, i, o), n !== null && (ur(o, "this.forceUpdate()", e), We(n, e, o), Bi(n, e, o));
13411
- } }, bd = null, Cg = null, Tg = Error("This is not a real error. It's an implementation detail of React's selective hydration feature. If this leaks into userspace, it's a bug in React. Please file an issue."), Cn = false, $y = {}, Vy = {}, qy = {}, Gy = {}, vd = false, Jy = {}, fm = {}, _g = { dehydrated: null, treeContext: null, retryLane: 0, hydrationErrors: null }, Zy = false, Yy = null;
13412
- Yy = /* @__PURE__ */ new Set();
13413
- var Si = false, Tn = false, Rg = false, Xy = typeof WeakSet == "function" ? WeakSet : Set, Gn = null, Sd = null, kd = null, _n = null, nr = false, Vo = null, Wn = false, wd = 8192, Vb = { getCacheForType: function(e) {
13414
- var n = Ee(un), o = n.data.get(e);
13415
- return o === void 0 && (o = e(), n.data.set(e, o)), o;
13416
- }, cacheSignal: function() {
13417
- return Ee(un).controller.signal;
13418
- }, getOwner: function() {
13419
- return di;
13420
- } }, pm = 0, hm = 1, mm = 2, gm = 3, ym = 4;
13421
- if (typeof Symbol == "function" && Symbol.for) {
13422
- var bp = Symbol.for;
13423
- pm = bp("selector.component"), hm = bp("selector.has_pseudo_class"), mm = bp("selector.role"), gm = bp("selector.test_id"), ym = bp("selector.text");
12996
+ });
12997
+ }
12998
+ }
12999
+ unregisterVisibility(store, object);
13000
+ }
13001
+ function removeInteractivity(store, object) {
13002
+ const { internal } = store.getState();
13003
+ internal.interaction = internal.interaction.filter((o) => o !== object);
13004
+ for (const [pointerId, pointerState] of internal.pointerMap) {
13005
+ pointerState.initialHits = pointerState.initialHits.filter((o) => o !== object);
13006
+ pointerState.hovered.forEach((value, key) => {
13007
+ if (value.eventObject === object || value.object === object) {
13008
+ pointerState.hovered.delete(key);
13424
13009
  }
13425
- var bm = [], qb = typeof WeakMap == "function" ? WeakMap : Map, Jn = 0, Zn = 2, uo = 4, ki = 0, vp = 1, iu = 2, vm = 3, Tl = 4, Sm = 6, Ky = 5, ye = Jn, je = null, se = null, ae = 0, tr = 0, km = 1, lu = 2, Sp = 3, eb = 4, Eg = 5, kp = 6, wm = 7, Ig = 8, su = 9, Le = tr, Er = null, _l = false, Pd = false, Lg = false, Ta = 0, nn = ki, Rl = 0, El = 0, Ng = 0, rr = 0, uu = 0, wp = null, Bt = null, Pm = false, xm = 0, nb = 0, tb = 300, Pp = 1 / 0, Fg = 500, xp = null, gn = null, Il = null, zm = 0, Hg = 1, Ag = 2, rb = 3, Ll = 0, ob = 1, ab = 2, ib = 3, lb = 4, Cm = 5, Rn = 0, Nl = null, xd = null, qo = 0, jg = 0, Dg = -0, Wg = null, sb = null, ub = null, Go = zm, cb = null, Gb = 50, zp = 0, Ug = null, Bg = false, Tm = false, Jb = 50, cu = 0, Cp = null, zd = false, _m = null, db = false, fb = /* @__PURE__ */ new Set(), Zb = {}, co = null, Cd = null, pb = false;
13426
- try {
13427
- var o0 = Object.preventExtensions({});
13428
- } catch {
13429
- pb = true;
13010
+ });
13011
+ if (pointerState.captured.has(object)) {
13012
+ releaseInternalPointerCapture(internal, object, pointerId);
13013
+ }
13014
+ }
13015
+ unregisterVisibility(store, object);
13016
+ }
13017
+ function createEvents(store) {
13018
+ function calculateDistance(event, pointerId) {
13019
+ const { internal } = store.getState();
13020
+ const pointerState = internal.pointerMap.get(pointerId);
13021
+ if (!pointerState) return 0;
13022
+ const [initialX, initialY] = pointerState.initialClick;
13023
+ const dx = event.offsetX - initialX;
13024
+ const dy = event.offsetY - initialY;
13025
+ return Math.round(Math.sqrt(dx * dx + dy * dy));
13026
+ }
13027
+ function filterPointerEvents(objects) {
13028
+ return objects.filter(
13029
+ (obj) => ["Move", "Over", "Enter", "Out", "Leave"].some(
13030
+ (name) => obj.__r3f?.handlers["onPointer" + name]
13031
+ ) || ["OverEnter", "OverLeave", "Over"].some(
13032
+ (name) => obj.__r3f?.handlers["onDrag" + name]
13033
+ ) || obj.__r3f?.handlers.onDrop
13034
+ );
13035
+ }
13036
+ function intersect(event, filter) {
13037
+ const state = store.getState();
13038
+ const duplicates = /* @__PURE__ */ new Set();
13039
+ const intersections = [];
13040
+ const eventsObjects = filter ? filter(state.internal.interaction) : state.internal.interaction;
13041
+ for (let i = 0; i < eventsObjects.length; i++) {
13042
+ const state2 = getRootState(eventsObjects[i]);
13043
+ if (state2) {
13044
+ state2.raycaster.camera = void 0;
13430
13045
  }
13431
- var hb = false, mb = {}, gb = null, yb = null, bb = null, vb = null, Sb = null, kb = null, wb = null, Pb = null, xb = null, zb = null;
13432
- return gb = function(e, n, o, i) {
13433
- n = Yn(e, n), n !== null && (o = _d(n.memoizedState, o, 0, i), n.memoizedState = o, n.baseState = o, e.memoizedProps = ze({}, e.memoizedProps), o = On(e, 2), o !== null && We(o, e, 2));
13434
- }, yb = function(e, n, o) {
13435
- n = Yn(e, n), n !== null && (o = du(n.memoizedState, o, 0), n.memoizedState = o, n.baseState = o, e.memoizedProps = ze({}, e.memoizedProps), o = On(e, 2), o !== null && We(o, e, 2));
13436
- }, bb = function(e, n, o, i) {
13437
- n = Yn(e, n), n !== null && (o = F(n.memoizedState, o, i), n.memoizedState = o, n.baseState = o, e.memoizedProps = ze({}, e.memoizedProps), o = On(e, 2), o !== null && We(o, e, 2));
13438
- }, vb = function(e, n, o) {
13439
- e.pendingProps = _d(e.memoizedProps, n, 0, o), e.alternate && (e.alternate.pendingProps = e.pendingProps), n = On(e, 2), n !== null && We(n, e, 2);
13440
- }, Sb = function(e, n) {
13441
- e.pendingProps = du(e.memoizedProps, n, 0), e.alternate && (e.alternate.pendingProps = e.pendingProps), n = On(e, 2), n !== null && We(n, e, 2);
13442
- }, kb = function(e, n, o) {
13443
- e.pendingProps = F(e.memoizedProps, n, o), e.alternate && (e.alternate.pendingProps = e.pendingProps), n = On(e, 2), n !== null && We(n, e, 2);
13444
- }, wb = function(e) {
13445
- var n = On(e, 2);
13446
- n !== null && We(n, e, 2);
13447
- }, Pb = function(e) {
13448
- var n = ut(), o = On(e, n);
13449
- o !== null && We(o, e, n);
13450
- }, xb = function(e) {
13451
- pu = e;
13452
- }, zb = function(e) {
13453
- fu = e;
13454
- }, le.attemptContinuousHydration = function(e) {
13455
- if (e.tag === 13 || e.tag === 31) {
13456
- var n = On(e, 67108864);
13457
- n !== null && We(n, e, 67108864), rl(e, 67108864);
13046
+ }
13047
+ if (!state.previousRoot) {
13048
+ state.events.compute?.(event, state);
13049
+ }
13050
+ function handleRaycast(obj) {
13051
+ const state2 = getRootState(obj);
13052
+ if (!state2 || !state2.events.enabled || state2.raycaster.camera === null) return [];
13053
+ if (state2.raycaster.camera === void 0) {
13054
+ state2.events.compute?.(event, state2, state2.previousRoot?.getState());
13055
+ if (state2.raycaster.camera === void 0) state2.raycaster.camera = null;
13056
+ }
13057
+ if (!state2.raycaster.camera) return [];
13058
+ obj.updateWorldMatrix(true, true);
13059
+ return state2.raycaster.intersectObject(obj, true);
13060
+ }
13061
+ let hits = eventsObjects.flatMap(handleRaycast).sort((a, b) => {
13062
+ const aInteractivePriority = a.object.userData?.interactivePriority;
13063
+ const bInteractivePriority = b.object.userData?.interactivePriority;
13064
+ if (aInteractivePriority !== void 0 || bInteractivePriority !== void 0) {
13065
+ if (aInteractivePriority !== void 0 && bInteractivePriority === void 0) return -1;
13066
+ if (bInteractivePriority !== void 0 && aInteractivePriority === void 0) return 1;
13067
+ if (aInteractivePriority !== bInteractivePriority) {
13068
+ return (bInteractivePriority ?? 0) - (aInteractivePriority ?? 0);
13458
13069
  }
13459
- }, le.attemptHydrationAtCurrentPriority = function(e) {
13460
- if (e.tag === 13 || e.tag === 31) {
13461
- var n = Nt(e);
13462
- n = Xo(n);
13463
- var o = On(e, n);
13464
- o !== null && We(o, e, n), rl(e, n);
13070
+ }
13071
+ const aState = getRootState(a.object);
13072
+ const bState = getRootState(b.object);
13073
+ const aPriority = aState?.events?.priority ?? 1;
13074
+ const bPriority = bState?.events?.priority ?? 1;
13075
+ return bPriority - aPriority || a.distance - b.distance;
13076
+ }).filter((item) => {
13077
+ const id = makeId(item);
13078
+ if (duplicates.has(id)) return false;
13079
+ duplicates.add(id);
13080
+ return true;
13081
+ });
13082
+ if (state.events.filter) hits = state.events.filter(hits, state);
13083
+ for (const hit of hits) {
13084
+ let eventObject = hit.object;
13085
+ while (eventObject) {
13086
+ if (eventObject.__r3f?.eventCount) {
13087
+ intersections.push({ ...hit, eventObject });
13465
13088
  }
13466
- }, le.attemptSynchronousHydration = function(e) {
13467
- switch (e.tag) {
13468
- case 3:
13469
- if (e = e.stateNode, e.current.memoizedState.isDehydrated) {
13470
- var n = _t(e.pendingLanes);
13471
- if (n !== 0) {
13472
- for (e.pendingLanes |= 2, e.entangledLanes |= 2; n; ) {
13473
- var o = 1 << 31 - vn(n);
13474
- e.entanglements[1] |= o, n &= ~o;
13089
+ eventObject = eventObject.parent;
13090
+ }
13091
+ }
13092
+ if ("pointerId" in event) {
13093
+ const pointerId = event.pointerId;
13094
+ const pointerState = state.internal.pointerMap.get(pointerId);
13095
+ if (pointerState?.captured.size) {
13096
+ for (const captureData of pointerState.captured.values()) {
13097
+ if (!duplicates.has(makeId(captureData.intersection))) intersections.push(captureData.intersection);
13098
+ }
13099
+ }
13100
+ }
13101
+ return intersections;
13102
+ }
13103
+ function handleIntersects(intersections, event, delta, callback) {
13104
+ if (intersections.length) {
13105
+ const localState = { stopped: false };
13106
+ for (const hit of intersections) {
13107
+ const state = getRootState(hit.object);
13108
+ if (state) {
13109
+ const { raycaster, pointer, camera, internal } = state;
13110
+ const unprojectedPoint = new Vector3(pointer.x, pointer.y, 0).unproject(camera);
13111
+ const hasPointerCapture = (id) => {
13112
+ const pointerState = internal.pointerMap.get(id);
13113
+ return pointerState?.captured.has(hit.eventObject) ?? false;
13114
+ };
13115
+ const setPointerCapture = (id) => {
13116
+ const captureData = { intersection: hit, target: event.target };
13117
+ const pointerState = getPointerState(internal, id);
13118
+ pointerState.captured.set(hit.eventObject, captureData);
13119
+ event.target.setPointerCapture(id);
13120
+ };
13121
+ const releasePointerCapture = (id) => {
13122
+ releaseInternalPointerCapture(internal, hit.eventObject, id);
13123
+ };
13124
+ const extractEventProps = {};
13125
+ for (const prop in event) {
13126
+ const property = event[prop];
13127
+ if (typeof property !== "function") extractEventProps[prop] = property;
13128
+ }
13129
+ const eventPointerId = "pointerId" in event ? event.pointerId : void 0;
13130
+ const raycastEvent = {
13131
+ ...hit,
13132
+ ...extractEventProps,
13133
+ pointer,
13134
+ intersections,
13135
+ stopped: localState.stopped,
13136
+ delta,
13137
+ unprojectedPoint,
13138
+ ray: raycaster.ray,
13139
+ camera,
13140
+ pointerId: eventPointerId,
13141
+ // Hijack stopPropagation, which just sets a flag
13142
+ stopPropagation() {
13143
+ const pointerState = eventPointerId !== void 0 ? internal.pointerMap.get(eventPointerId) : void 0;
13144
+ if (
13145
+ // ...if this pointer hasn't been captured
13146
+ !pointerState?.captured.size || // ... or if the hit object is capturing the pointer
13147
+ pointerState.captured.has(hit.eventObject)
13148
+ ) {
13149
+ raycastEvent.stopped = localState.stopped = true;
13150
+ if (pointerState?.hovered.size && Array.from(pointerState.hovered.values()).find((i) => i.eventObject === hit.eventObject)) {
13151
+ const higher = intersections.slice(0, intersections.indexOf(hit));
13152
+ cancelPointer([...higher, hit], eventPointerId);
13475
13153
  }
13476
- Kn(e), (ye & (Zn | uo)) === Jn && (Pp = me() + Fg, Wa(0));
13477
13154
  }
13478
- }
13479
- break;
13480
- case 31:
13481
- case 13:
13482
- n = On(e, 2), n !== null && We(n, e, 2), Ls(), rl(e, 2);
13155
+ },
13156
+ // there should be a distinction between target and currentTarget
13157
+ target: { hasPointerCapture, setPointerCapture, releasePointerCapture },
13158
+ currentTarget: { hasPointerCapture, setPointerCapture, releasePointerCapture },
13159
+ nativeEvent: event
13160
+ };
13161
+ callback(raycastEvent);
13162
+ if (localState.stopped === true) break;
13483
13163
  }
13484
- }, le.batchedUpdates = function(e, n) {
13485
- return e(n);
13486
- }, le.createComponentSelector = function(e) {
13487
- return { $$typeof: pm, value: e };
13488
- }, le.createContainer = function(e, n, o, i, s, u, f, p, g, S) {
13489
- return Ka(e, n, false, null, o, i, u, null, f, p, g, S);
13490
- }, le.createHasPseudoClassSelector = function(e) {
13491
- return { $$typeof: hm, value: e };
13492
- }, le.createHydrationContainer = function(e, n, o, i, s, u, f, p, g, S, T, _, I, O) {
13493
- return e = Ka(o, i, true, e, s, u, p, O, g, S, T, _), e.context = Dh(null), o = e.current, i = Nt(o), i = Xo(i), s = zo(i), s.callback = n ?? null, Mt(o, s, i), ur(i, "hydrateRoot()", null), n = i, e.current.lanes = n, Ci(e, n), Kn(e), e;
13494
- }, le.createPortal = function(e, n, o) {
13495
- var i = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
13496
- try {
13497
- vt(i);
13498
- var s = false;
13499
- } catch {
13500
- s = true;
13164
+ }
13165
+ }
13166
+ return intersections;
13167
+ }
13168
+ function cancelPointer(intersections, pointerId) {
13169
+ const { internal } = store.getState();
13170
+ const pid = pointerId ?? DEFAULT_POINTER_ID;
13171
+ const pointerState = internal.pointerMap.get(pid);
13172
+ if (!pointerState) return;
13173
+ for (const [hoveredId, hoveredObj] of pointerState.hovered) {
13174
+ if (!intersections.length || !intersections.find(
13175
+ (hit) => hit.object === hoveredObj.object && hit.index === hoveredObj.index && hit.instanceId === hoveredObj.instanceId
13176
+ )) {
13177
+ const eventObject = hoveredObj.eventObject;
13178
+ const instance = eventObject.__r3f;
13179
+ pointerState.hovered.delete(hoveredId);
13180
+ if (instance?.eventCount) {
13181
+ const handlers = instance.handlers;
13182
+ const data = { ...hoveredObj, intersections };
13183
+ handlers.onPointerOut?.(data);
13184
+ handlers.onPointerLeave?.(data);
13185
+ handlers.onDragOverLeave?.(data);
13501
13186
  }
13502
- return s && (console.error("The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", typeof Symbol == "function" && Symbol.toStringTag && i[Symbol.toStringTag] || i.constructor.name || "Object"), vt(i)), { $$typeof: Ao, key: i == null ? null : "" + i, children: e, containerInfo: n, implementation: o };
13503
- }, le.createRoleSelector = function(e) {
13504
- return { $$typeof: mm, value: e };
13505
- }, le.createTestNameSelector = function(e) {
13506
- return { $$typeof: gm, value: e };
13507
- }, le.createTextSelector = function(e) {
13508
- return { $$typeof: ym, value: e };
13509
- }, le.defaultOnCaughtError = function(e) {
13510
- var n = bd ? "The above error occurred in the <" + bd + "> component." : "The above error occurred in one of your React components.", o = "React will try to recreate this component tree from scratch using the error boundary you provided, " + ((Cg || "Anonymous") + ".");
13511
- typeof e == "object" && e !== null && typeof e.environmentName == "string" ? ri("error", [`%o
13512
-
13513
- %s
13514
-
13515
- %s
13516
- `, e, n, o], e.environmentName)() : console.error(`%o
13517
-
13518
- %s
13519
-
13520
- %s
13521
- `, e, n, o);
13522
- }, le.defaultOnRecoverableError = function(e) {
13523
- qg(e);
13524
- }, le.defaultOnUncaughtError = function(e) {
13525
- qg(e), console.warn(`%s
13526
-
13527
- %s
13528
- `, bd ? "An error occurred in the <" + bd + "> component." : "An error occurred in one of your React components.", `Consider adding an error boundary to your tree to customize error handling behavior.
13529
- Visit https://react.dev/link/error-boundaries to learn more about error boundaries.`);
13530
- }, le.deferredUpdates = function(e) {
13531
- var n = x.T, o = wt();
13532
- try {
13533
- return an(32), x.T = null, e();
13534
- } finally {
13535
- an(o), x.T = n;
13187
+ }
13188
+ }
13189
+ }
13190
+ function pointerMissed(event, objects) {
13191
+ for (let i = 0; i < objects.length; i++) {
13192
+ const instance = objects[i].__r3f;
13193
+ instance?.handlers.onPointerMissed?.(event);
13194
+ }
13195
+ }
13196
+ function dragOverMissed(event, objects) {
13197
+ for (let i = 0; i < objects.length; i++) {
13198
+ const instance = objects[i].__r3f;
13199
+ instance?.handlers.onDragOverMissed?.(event);
13200
+ }
13201
+ }
13202
+ function dropMissed(event, objects) {
13203
+ for (let i = 0; i < objects.length; i++) {
13204
+ const instance = objects[i].__r3f;
13205
+ instance?.handlers.onDropMissed?.(event);
13206
+ }
13207
+ }
13208
+ function cleanupPointer(pointerId) {
13209
+ const { internal } = store.getState();
13210
+ const pointerState = internal.pointerMap.get(pointerId);
13211
+ if (pointerState) {
13212
+ for (const [, hoveredObj] of pointerState.hovered) {
13213
+ const eventObject = hoveredObj.eventObject;
13214
+ const instance = eventObject.__r3f;
13215
+ if (instance?.eventCount) {
13216
+ const handlers = instance.handlers;
13217
+ const data = { ...hoveredObj, intersections: [] };
13218
+ handlers.onPointerOut?.(data);
13219
+ handlers.onPointerLeave?.(data);
13536
13220
  }
13537
- }, le.discreteUpdates = function(e, n, o, i, s) {
13538
- var u = x.T, f = wt();
13539
- try {
13540
- return an(2), x.T = null, e(n, o, i, s);
13541
- } finally {
13542
- an(f), x.T = u, ye === Jn && (Pp = me() + Fg);
13221
+ }
13222
+ internal.pointerMap.delete(pointerId);
13223
+ }
13224
+ internal.pointerDirty.delete(pointerId);
13225
+ }
13226
+ function processDeferredPointer(event, pointerId) {
13227
+ const state = store.getState();
13228
+ const { internal } = state;
13229
+ if (!state.events.enabled) return;
13230
+ const filter = filterPointerEvents;
13231
+ const hits = intersect(event, filter);
13232
+ cancelPointer(hits, pointerId);
13233
+ function onIntersect(data) {
13234
+ const eventObject = data.eventObject;
13235
+ const instance = eventObject.__r3f;
13236
+ if (!instance?.eventCount) return;
13237
+ const handlers = instance.handlers;
13238
+ if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) {
13239
+ const id = makeId(data);
13240
+ const pointerState = getPointerState(internal, pointerId);
13241
+ const hoveredItem = pointerState.hovered.get(id);
13242
+ if (!hoveredItem) {
13243
+ pointerState.hovered.set(id, data);
13244
+ handlers.onPointerOver?.(data);
13245
+ handlers.onPointerEnter?.(data);
13246
+ } else if (hoveredItem.stopped) {
13247
+ data.stopPropagation();
13543
13248
  }
13544
- }, le.findAllNodes = kc, le.findBoundingRects = function(e, n) {
13545
- if (!xr) throw Error("Test selector API is not supported by this renderer.");
13546
- n = kc(e, n), e = [];
13547
- for (var o = 0; o < n.length; o++) e.push(ma(n[o]));
13548
- for (n = e.length - 1; 0 < n; n--) {
13549
- o = e[n];
13550
- for (var i = o.x, s = i + o.width, u = o.y, f = u + o.height, p = n - 1; 0 <= p; p--) if (n !== p) {
13551
- var g = e[p], S = g.x, T = S + g.width, _ = g.y, I = _ + g.height;
13552
- if (i >= S && u >= _ && s <= T && f <= I) {
13553
- e.splice(n, 1);
13554
- break;
13555
- } else if (i !== S || o.width !== g.width || I < u || _ > f) {
13556
- if (!(u !== _ || o.height !== g.height || T < i || S > s)) {
13557
- S > i && (g.width += S - i, g.x = i), T < s && (g.width = s - S), e.splice(n, 1);
13558
- break;
13249
+ }
13250
+ handlers.onPointerMove?.(data);
13251
+ }
13252
+ handleIntersects(hits, event, 0, onIntersect);
13253
+ }
13254
+ function handlePointer(name) {
13255
+ switch (name) {
13256
+ case "onPointerLeave":
13257
+ case "onDragLeave":
13258
+ return () => cancelPointer([]);
13259
+ // Global cancel of these events
13260
+ case "onPointerCancel":
13261
+ return (event) => {
13262
+ const pointerId = getPointerId(event);
13263
+ cleanupPointer(pointerId);
13264
+ };
13265
+ case "onLostPointerCapture":
13266
+ return (event) => {
13267
+ const { internal } = store.getState();
13268
+ const pointerId = getPointerId(event);
13269
+ const pointerState = internal.pointerMap.get(pointerId);
13270
+ if (pointerState?.captured.size) {
13271
+ requestAnimationFrame(() => {
13272
+ const pointerState2 = internal.pointerMap.get(pointerId);
13273
+ if (pointerState2?.captured.size) {
13274
+ pointerState2.captured.clear();
13559
13275
  }
13560
- } else {
13561
- _ > u && (g.height += _ - u, g.y = u), I < f && (g.height = f - _), e.splice(n, 1);
13562
- break;
13276
+ cancelPointer([], pointerId);
13277
+ });
13278
+ }
13279
+ };
13280
+ }
13281
+ return function handleEvent(event) {
13282
+ const state = store.getState();
13283
+ const { onPointerMissed, onDragOverMissed, onDropMissed, internal, events } = state;
13284
+ const pointerId = getPointerId(event);
13285
+ internal.lastEvent.current = event;
13286
+ if (!events.enabled) return;
13287
+ const isPointerMove = name === "onPointerMove";
13288
+ const isDragOver = name === "onDragOver";
13289
+ const isDrop = name === "onDrop";
13290
+ const isClickEvent = name === "onClick" || name === "onContextMenu" || name === "onDoubleClick";
13291
+ const isPointerDown = name === "onPointerDown";
13292
+ const isPointerUp = name === "onPointerUp";
13293
+ const isWheel = name === "onWheel";
13294
+ const canDeferRaycasts = events.frameTimedRaycasts && state.frameloop === "always";
13295
+ if (isPointerMove && canDeferRaycasts) {
13296
+ events.compute?.(event, state);
13297
+ internal.pointerDirty.set(pointerId, event);
13298
+ return;
13299
+ }
13300
+ if (isWheel && canDeferRaycasts && !events.alwaysFireOnScroll) {
13301
+ events.compute?.(event, state);
13302
+ internal.pointerDirty.set(pointerId, event);
13303
+ return;
13304
+ }
13305
+ if ((isClickEvent || isPointerDown || isPointerUp) && internal.pointerDirty.has(pointerId)) {
13306
+ const deferredEvent = internal.pointerDirty.get(pointerId);
13307
+ internal.pointerDirty.delete(pointerId);
13308
+ processDeferredPointer(deferredEvent, pointerId);
13309
+ }
13310
+ const filter = isPointerMove || isDragOver || isDrop ? filterPointerEvents : void 0;
13311
+ const hits = intersect(event, filter);
13312
+ const delta = isClickEvent ? calculateDistance(event, pointerId) : 0;
13313
+ if (isPointerDown) {
13314
+ const pointerState2 = getPointerState(internal, pointerId);
13315
+ pointerState2.initialClick = [event.offsetX, event.offsetY];
13316
+ pointerState2.initialHits = hits.map((hit) => hit.eventObject);
13317
+ }
13318
+ const pointerState = internal.pointerMap.get(pointerId);
13319
+ const initialHits = pointerState?.initialHits ?? [];
13320
+ if (isClickEvent && !hits.length) {
13321
+ if (delta <= 2) {
13322
+ pointerMissed(event, internal.interaction);
13323
+ if (onPointerMissed) onPointerMissed(event);
13324
+ }
13325
+ }
13326
+ if (isDragOver && !hits.length) {
13327
+ dragOverMissed(event, internal.interaction);
13328
+ if (onDragOverMissed) onDragOverMissed(event);
13329
+ }
13330
+ if (isDrop && !hits.length) {
13331
+ dropMissed(event, internal.interaction);
13332
+ if (onDropMissed) onDropMissed(event);
13333
+ }
13334
+ if (isPointerMove || isDragOver) {
13335
+ cancelPointer(hits, pointerId);
13336
+ }
13337
+ function onIntersect(data) {
13338
+ const eventObject = data.eventObject;
13339
+ const instance = eventObject.__r3f;
13340
+ if (!instance?.eventCount) return;
13341
+ const handlers = instance.handlers;
13342
+ if (isPointerMove) {
13343
+ if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) {
13344
+ const id = makeId(data);
13345
+ const pointerState2 = getPointerState(internal, pointerId);
13346
+ const hoveredItem = pointerState2.hovered.get(id);
13347
+ if (!hoveredItem) {
13348
+ pointerState2.hovered.set(id, data);
13349
+ handlers.onPointerOver?.(data);
13350
+ handlers.onPointerEnter?.(data);
13351
+ } else if (hoveredItem.stopped) {
13352
+ data.stopPropagation();
13563
13353
  }
13564
13354
  }
13565
- }
13566
- return e;
13567
- }, le.findHostInstance = function(e) {
13568
- var n = e._reactInternals;
13569
- if (n === void 0) throw typeof e.render == "function" ? Error("Unable to find node on an unmounted component.") : (e = Object.keys(e).join(","), Error("Argument appears to not be a ReactComponent. Keys: " + e));
13570
- return e = mu(n), e === null ? null : ot(e.stateNode);
13571
- }, le.findHostInstanceWithNoPortals = function(e) {
13572
- return e = Ed(e), e = e !== null ? _p(e) : null, e === null ? null : ot(e.stateNode);
13573
- }, le.findHostInstanceWithWarning = function(e, n) {
13574
- var o = e._reactInternals;
13575
- if (o === void 0) throw typeof e.render == "function" ? Error("Unable to find node on an unmounted component.") : (e = Object.keys(e).join(","), Error("Argument appears to not be a ReactComponent. Keys: " + e));
13576
- if (e = mu(o), e === null) return null;
13577
- if (e.mode & 8) {
13578
- var i = G(o) || "Component";
13579
- mb[i] || (mb[i] = true, B(e, function() {
13580
- o.mode & 8 ? console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which is inside StrictMode. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", n, n, i) : console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which renders StrictMode children. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", n, n, i);
13581
- }));
13582
- }
13583
- return ot(e.stateNode);
13584
- }, le.flushPassiveEffects = el, le.flushSyncFromReconciler = function(e) {
13585
- var n = ye;
13586
- ye |= 1;
13587
- var o = x.T, i = wt();
13588
- try {
13589
- if (an(2), x.T = null, e) return e();
13590
- } finally {
13591
- an(i), x.T = o, ye = n, (ye & (Zn | uo)) === Jn && Wa(0);
13592
- }
13593
- }, le.flushSyncWork = Ls, le.focusWithin = function(e, n) {
13594
- if (!xr) throw Error("Test selector API is not supported by this renderer.");
13595
- for (e = Ef(e), n = hh(e, n), n = Array.from(n), e = 0; e < n.length; ) {
13596
- var o = n[e++], i = o.tag;
13597
- if (!Kr(o)) {
13598
- if ((i === 5 || i === 26 || i === 27) && Ft(o.stateNode)) return true;
13599
- for (o = o.child; o !== null; ) n.push(o), o = o.sibling;
13355
+ handlers.onPointerMove?.(data);
13356
+ } else if (isDragOver) {
13357
+ const id = makeId(data);
13358
+ const pointerState2 = getPointerState(internal, pointerId);
13359
+ const hoveredItem = pointerState2.hovered.get(id);
13360
+ if (!hoveredItem) {
13361
+ pointerState2.hovered.set(id, data);
13362
+ handlers.onDragOverEnter?.(data);
13363
+ } else if (hoveredItem.stopped) {
13364
+ data.stopPropagation();
13365
+ }
13366
+ handlers.onDragOver?.(data);
13367
+ } else if (isDrop) {
13368
+ handlers.onDrop?.(data);
13369
+ } else {
13370
+ const handler = handlers[name];
13371
+ if (handler) {
13372
+ if (!isClickEvent || initialHits.includes(eventObject)) {
13373
+ pointerMissed(
13374
+ event,
13375
+ internal.interaction.filter((object) => !initialHits.includes(object))
13376
+ );
13377
+ handler(data);
13378
+ }
13379
+ } else {
13380
+ if (isClickEvent && initialHits.includes(eventObject)) {
13381
+ pointerMissed(
13382
+ event,
13383
+ internal.interaction.filter((object) => !initialHits.includes(object))
13384
+ );
13385
+ }
13600
13386
  }
13601
13387
  }
13602
- return false;
13603
- }, le.getFindAllNodesFailureDescription = function(e, n) {
13604
- if (!xr) throw Error("Test selector API is not supported by this renderer.");
13605
- var o = 0, i = [];
13606
- e = [Ef(e), 0];
13607
- for (var s = 0; s < e.length; ) {
13608
- var u = e[s++], f = u.tag, p = e[s++], g = n[p];
13609
- if ((f !== 5 && f !== 26 && f !== 27 || !Kr(u)) && (If(u, g) && (i.push(Sc(g)), p++, p > o && (o = p)), p < n.length)) for (u = u.child; u !== null; ) e.push(u, p), u = u.sibling;
13388
+ }
13389
+ handleIntersects(hits, event, delta, onIntersect);
13390
+ };
13391
+ }
13392
+ function flushDeferredPointers() {
13393
+ const { internal, events } = store.getState();
13394
+ if (!events.frameTimedRaycasts) return;
13395
+ for (const [pointerId, event] of internal.pointerDirty) {
13396
+ processDeferredPointer(event, pointerId);
13397
+ }
13398
+ internal.pointerDirty.clear();
13399
+ }
13400
+ return { handlePointer, flushDeferredPointers, processDeferredPointer };
13401
+ }
13402
+ const DOM_EVENTS = {
13403
+ onClick: ["click", false],
13404
+ onContextMenu: ["contextmenu", false],
13405
+ onDoubleClick: ["dblclick", false],
13406
+ onDragEnter: ["dragenter", false],
13407
+ onDragLeave: ["dragleave", false],
13408
+ onDragOver: ["dragover", false],
13409
+ onDrop: ["drop", false],
13410
+ onWheel: ["wheel", true],
13411
+ onPointerDown: ["pointerdown", true],
13412
+ onPointerUp: ["pointerup", true],
13413
+ onPointerLeave: ["pointerleave", true],
13414
+ onPointerMove: ["pointermove", true],
13415
+ onPointerCancel: ["pointercancel", true],
13416
+ onLostPointerCapture: ["lostpointercapture", true]
13417
+ };
13418
+ function createPointerEvents(store) {
13419
+ const { handlePointer, flushDeferredPointers, processDeferredPointer } = createEvents(store);
13420
+ let nextXRPointerId = XR_POINTER_ID_START;
13421
+ const xrPointers = /* @__PURE__ */ new Map();
13422
+ return {
13423
+ priority: 1,
13424
+ enabled: true,
13425
+ frameTimedRaycasts: true,
13426
+ alwaysFireOnScroll: true,
13427
+ updateOnFrame: false,
13428
+ compute(event, state) {
13429
+ state.pointer.set(event.offsetX / state.size.width * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
13430
+ state.raycaster.setFromCamera(state.pointer, state.camera);
13431
+ },
13432
+ connected: void 0,
13433
+ handlers: Object.keys(DOM_EVENTS).reduce(
13434
+ (acc, key) => ({ ...acc, [key]: handlePointer(key) }),
13435
+ {}
13436
+ ),
13437
+ update: (pointerId) => {
13438
+ const { events, internal } = store.getState();
13439
+ if (!events.handlers) return;
13440
+ if (pointerId !== void 0) {
13441
+ const event = internal.pointerDirty.get(pointerId);
13442
+ if (event) {
13443
+ internal.pointerDirty.delete(pointerId);
13444
+ processDeferredPointer(event, pointerId);
13445
+ } else if (internal.lastEvent?.current) {
13446
+ processDeferredPointer(internal.lastEvent.current, pointerId);
13610
13447
  }
13611
- if (o < n.length) {
13612
- for (e = []; o < n.length; o++) e.push(Sc(n[o]));
13613
- return `findAllNodes was able to match part of the selector:
13614
- ` + (i.join(" > ") + `
13615
-
13616
- No matching component was found for:
13617
- `) + e.join(" > ");
13448
+ } else {
13449
+ flushDeferredPointers();
13450
+ if (internal.lastEvent?.current) {
13451
+ events.handlers.onPointerMove(internal.lastEvent.current);
13618
13452
  }
13619
- return null;
13620
- }, le.getPublicRootInstance = function(e) {
13621
- if (e = e.current, !e.child) return null;
13622
- switch (e.child.tag) {
13623
- case 27:
13624
- case 5:
13625
- return ot(e.child.stateNode);
13626
- default:
13627
- return e.child.stateNode;
13453
+ }
13454
+ },
13455
+ flush: () => {
13456
+ const { events, internal } = store.getState();
13457
+ flushDeferredPointers();
13458
+ if (events.updateOnFrame && internal.lastEvent?.current && events.handlers) {
13459
+ events.handlers.onPointerMove(internal.lastEvent.current);
13460
+ }
13461
+ },
13462
+ connect: (target) => {
13463
+ if (!target) return;
13464
+ const { set, events } = store.getState();
13465
+ events.disconnect?.();
13466
+ set((state) => ({ events: { ...state.events, connected: target } }));
13467
+ if (events.handlers) {
13468
+ for (const name in events.handlers) {
13469
+ const event = events.handlers[name];
13470
+ const [eventName, passive] = DOM_EVENTS[name];
13471
+ target.addEventListener(eventName, event, { passive });
13628
13472
  }
13629
- }, le.injectIntoDevTools = function() {
13630
- var e = { bundleType: 1, version: Jt, rendererPackageName: Zt, currentDispatcherRef: x, reconcilerVersion: "19.2.0" };
13631
- return jo !== null && (e.rendererConfig = jo), e.overrideHookState = gb, e.overrideHookStateDeletePath = yb, e.overrideHookStateRenamePath = bb, e.overrideProps = vb, e.overridePropsDeletePath = Sb, e.overridePropsRenamePath = kb, e.scheduleUpdate = wb, e.scheduleRetry = Pb, e.setErrorHandler = xb, e.setSuspenseHandler = zb, e.scheduleRefresh = hu, e.scheduleRoot = Fl, e.setRefreshHandler = Ir, e.getCurrentFiber = Ic, Ep(e);
13632
- }, le.isAlreadyRendering = Ns, le.observeVisibleRects = function(e, n, o, i) {
13633
- function s() {
13634
- var S = kc(e, n);
13635
- u.forEach(function(T) {
13636
- 0 > S.indexOf(T) && g(T);
13637
- }), S.forEach(function(T) {
13638
- 0 > u.indexOf(T) && p(T);
13639
- });
13473
+ }
13474
+ },
13475
+ disconnect: () => {
13476
+ const { set, events } = store.getState();
13477
+ if (events.connected) {
13478
+ if (events.handlers) {
13479
+ for (const name in events.handlers) {
13480
+ const event = events.handlers[name];
13481
+ const [eventName] = DOM_EVENTS[name];
13482
+ events.connected.removeEventListener(eventName, event);
13483
+ }
13484
+ }
13485
+ set((state) => ({ events: { ...state.events, connected: void 0 } }));
13486
+ }
13487
+ },
13488
+ // PREVIEW (A8): the XR pointer registration API may change before stable.
13489
+ registerPointer: (config) => {
13490
+ const pointerId = nextXRPointerId++;
13491
+ xrPointers.set(pointerId, config);
13492
+ const { internal } = store.getState();
13493
+ getPointerState(internal, pointerId);
13494
+ return pointerId;
13495
+ },
13496
+ unregisterPointer: (pointerId) => {
13497
+ xrPointers.delete(pointerId);
13498
+ const { internal } = store.getState();
13499
+ const pointerState = internal.pointerMap.get(pointerId);
13500
+ if (pointerState) {
13501
+ for (const [, hoveredObj] of pointerState.hovered) {
13502
+ const eventObject = hoveredObj.eventObject;
13503
+ const instance = eventObject.__r3f;
13504
+ if (instance?.eventCount) {
13505
+ const handlers = instance.handlers;
13506
+ const data = { ...hoveredObj, intersections: [] };
13507
+ handlers.onPointerOut?.(data);
13508
+ handlers.onPointerLeave?.(data);
13509
+ }
13640
13510
  }
13641
- if (!xr) throw Error("Test selector API is not supported by this renderer.");
13642
- var u = kc(e, n);
13643
- o = zr(u, o, i);
13644
- var f = o.disconnect, p = o.observe, g = o.unobserve;
13645
- return bm.push(s), { disconnect: function() {
13646
- var S = bm.indexOf(s);
13647
- 0 <= S && bm.splice(S, 1), f();
13648
- } };
13649
- }, le.shouldError = function(e) {
13650
- return pu(e);
13651
- }, le.shouldSuspend = function(e) {
13652
- return fu(e);
13653
- }, le.startHostTransition = function(e, n, o, i) {
13654
- if (e.tag !== 5) throw Error("Expected the form instance to be a HostComponent. This is a bug in React.");
13655
- var s = uf(e).queue;
13656
- Hp(e), nt(e, s, n, Xt, o === null ? Em : function() {
13657
- x.T === null && console.error("requestFormReset was called outside a transition or action. To fix, move to an action, or wrap with startTransition.");
13658
- var u = uf(e);
13659
- return u.next === null && (u = e.alternate.memoizedState), qi(e, u.next.queue, {}, Nt(e)), o(i);
13660
- });
13661
- }, le.updateContainer = function(e, n, o, i) {
13662
- var s = n.current, u = Nt(s);
13663
- return As(s, u, e, n, o, i), u;
13664
- }, le.updateContainerSync = Wh, le;
13665
- }, Tt.exports.default = Tt.exports, Object.defineProperty(Tt.exports, "__esModule", { value: true }));
13666
- })(Mg)), Mg.exports;
13667
- }
13668
- var Eb;
13669
- function n0() {
13670
- return Eb || (Eb = 1, process.env.NODE_ENV === "production" ? Rm.exports = Kb() : Rm.exports = e0()), Rm.exports;
13511
+ internal.pointerMap.delete(pointerId);
13512
+ }
13513
+ internal.pointerDirty.delete(pointerId);
13514
+ }
13515
+ };
13671
13516
  }
13672
- var t0 = n0();
13673
- const r0 = Xb(t0);
13674
-
13675
- const t = 1, o = 8, r = 32, e = 2;
13676
13517
 
13677
13518
  function createReconciler(config) {
13678
13519
  const reconciler2 = r0(config);
@@ -13837,7 +13678,15 @@ function setFiberRef(fiber, publicInstance) {
13837
13678
  }
13838
13679
  }
13839
13680
  const reconstructed = [];
13840
- function swapInstances() {
13681
+ function flushReconstructedInstances() {
13682
+ if (reconstructed.length === 0) return;
13683
+ try {
13684
+ swapReconstructedInstances();
13685
+ } finally {
13686
+ reconstructed.length = 0;
13687
+ }
13688
+ }
13689
+ function swapReconstructedInstances() {
13841
13690
  for (const [instance] of reconstructed) {
13842
13691
  const parent = instance.parent;
13843
13692
  if (parent) {
@@ -13855,7 +13704,9 @@ function swapInstances() {
13855
13704
  }
13856
13705
  }
13857
13706
  if (instance.isHidden) unhideInstance(instance);
13858
- if (isObject3D(instance.object)) removeInteractivity(findInitialRoot(instance), instance.object);
13707
+ if (isObject3D(instance.object) && !instance.parent) {
13708
+ removeInteractivity(findInitialRoot(instance), instance.object);
13709
+ }
13859
13710
  if (instance.object.__r3f) delete instance.object.__r3f;
13860
13711
  if (instance.type !== "primitive") disposeOnIdle(instance.object);
13861
13712
  }
@@ -13864,9 +13715,13 @@ function swapInstances() {
13864
13715
  const parent = instance.parent;
13865
13716
  if (parent) {
13866
13717
  const target = catalogue[toPascalCase(instance.type)];
13718
+ const prevObject = instance.object;
13867
13719
  instance.object = instance.props.object ?? new target(...instance.props.args ?? []);
13868
13720
  instance.object.__r3f = instance;
13869
13721
  setFiberRef(fiber, instance.object);
13722
+ if (isObject3D(prevObject) && isObject3D(instance.object)) {
13723
+ swapInteractivity(findInitialRoot(instance), prevObject, instance.object);
13724
+ }
13870
13725
  delete instance.appliedOnce;
13871
13726
  instance.eventCount = 0;
13872
13727
  instance.handlers = {};
@@ -13886,14 +13741,114 @@ function swapInstances() {
13886
13741
  invalidateInstance(instance);
13887
13742
  }
13888
13743
  }
13889
- reconstructed.length = 0;
13890
13744
  }
13891
13745
  const handleTextInstance = () => {
13892
13746
  };
13893
13747
  const NO_CONTEXT = {};
13894
13748
  let currentUpdatePriority = NoEventPriority;
13895
- const NoFlags = 0;
13896
- const Update = 4;
13749
+ function getEventPriority(type) {
13750
+ switch (type) {
13751
+ case "beforetoggle":
13752
+ case "cancel":
13753
+ case "click":
13754
+ case "close":
13755
+ case "contextmenu":
13756
+ case "copy":
13757
+ case "cut":
13758
+ case "auxclick":
13759
+ case "dblclick":
13760
+ case "dragend":
13761
+ case "dragstart":
13762
+ case "drop":
13763
+ case "focusin":
13764
+ case "focusout":
13765
+ case "input":
13766
+ case "invalid":
13767
+ case "keydown":
13768
+ case "keypress":
13769
+ case "keyup":
13770
+ case "mousedown":
13771
+ case "mouseup":
13772
+ case "paste":
13773
+ case "pause":
13774
+ case "play":
13775
+ case "pointercancel":
13776
+ case "pointerdown":
13777
+ case "pointerup":
13778
+ case "ratechange":
13779
+ case "reset":
13780
+ case "resize":
13781
+ case "seeked":
13782
+ case "submit":
13783
+ case "touchcancel":
13784
+ case "touchend":
13785
+ case "touchstart":
13786
+ case "volumechange":
13787
+ case "change":
13788
+ case "selectionchange":
13789
+ case "compositionstart":
13790
+ case "compositionend":
13791
+ case "compositionupdate":
13792
+ case "beforeinput":
13793
+ case "blur":
13794
+ case "fullscreenchange":
13795
+ case "focus":
13796
+ case "hashchange":
13797
+ case "popstate":
13798
+ case "select":
13799
+ case "selectstart":
13800
+ return e;
13801
+ case "drag":
13802
+ case "dragenter":
13803
+ case "dragexit":
13804
+ case "dragleave":
13805
+ case "dragover":
13806
+ case "mousemove":
13807
+ case "mouseout":
13808
+ case "mouseover":
13809
+ case "pointermove":
13810
+ case "pointerout":
13811
+ case "pointerover":
13812
+ case "scroll":
13813
+ case "touchmove":
13814
+ case "wheel":
13815
+ case "mouseenter":
13816
+ case "mouseleave":
13817
+ case "pointerenter":
13818
+ case "pointerleave":
13819
+ return o;
13820
+ case "message": {
13821
+ switch (unstable_getCurrentPriorityLevel()) {
13822
+ case unstable_ImmediatePriority:
13823
+ return e;
13824
+ case unstable_UserBlockingPriority:
13825
+ return o;
13826
+ case unstable_NormalPriority:
13827
+ case unstable_LowPriority:
13828
+ return r;
13829
+ case unstable_IdlePriority:
13830
+ return i$1;
13831
+ default:
13832
+ return r;
13833
+ }
13834
+ }
13835
+ default:
13836
+ return r;
13837
+ }
13838
+ }
13839
+ function scheduleMicrotask(callback) {
13840
+ if (typeof queueMicrotask === "function") {
13841
+ queueMicrotask(callback);
13842
+ } else if (typeof Promise !== "undefined") {
13843
+ Promise.resolve().then(callback).catch((error) => {
13844
+ setTimeout(() => {
13845
+ throw error;
13846
+ });
13847
+ });
13848
+ } else {
13849
+ setTimeout(callback);
13850
+ }
13851
+ }
13897
13852
  const reconciler = /* @__PURE__ */ createReconciler({
13898
13853
  isPrimaryRenderer: false,
13899
13854
  warnsIfNotActing: false,
@@ -13932,16 +13887,15 @@ const reconciler = /* @__PURE__ */ createReconciler({
13932
13887
  else if (newProps.args?.length !== oldProps.args?.length) reconstruct = true;
13933
13888
  else if (newProps.args?.some((value, index) => value !== oldProps.args?.[index])) reconstruct = true;
13934
13889
  if (reconstruct) {
13935
- reconstructed.push([instance, { ...newProps }, fiber]);
13890
+ reconstructed.push([instance, getInstanceProps(newProps), fiber]);
13936
13891
  } else {
13937
13892
  const changedProps = diffProps(instance, newProps);
13938
- if (Object.keys(changedProps).length) {
13939
- Object.assign(instance.props, changedProps);
13940
- applyProps(instance.object, changedProps);
13941
- }
13893
+ const attach2 = instance.props.attach;
13894
+ instance.props = getInstanceProps(newProps);
13895
+ if (attach2 !== void 0) instance.props.attach = attach2;
13896
+ else delete instance.props.attach;
13897
+ if (Object.keys(changedProps).length) applyProps(instance.object, changedProps);
13942
13898
  }
13943
- const isTailSibling = fiber.sibling === null || (fiber.flags & Update) === NoFlags;
13944
- if (isTailSibling) swapInstances();
13945
13899
  },
13946
13900
  finalizeInitialChildren: (instance) => {
13947
13901
  for (const prop in instance.props) {
@@ -13966,8 +13920,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
13966
13920
  const target = container.getState().internal.container ?? container.getState().scene;
13967
13921
  return prepare(target, container, "", {});
13968
13922
  },
13969
- resetAfterCommit: () => {
13970
- },
13923
+ // Reconstructed instances are swapped once all mutations are committed,
13924
+ // before layout effects run so refs point to the new objects
13925
+ resetAfterCommit: flushReconstructedInstances,
13971
13926
  shouldSetTextContent: () => false,
13972
13927
  clearContainer: () => false,
13973
13928
  hideInstance,
@@ -13975,6 +13930,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
13975
13930
  createTextInstance: handleTextInstance,
13976
13931
  hideTextInstance: handleTextInstance,
13977
13932
  unhideTextInstance: handleTextInstance,
13933
+ // Mirrors react-dom, which flushes discrete work in microtasks
13934
+ supportsMicrotasks: true,
13935
+ scheduleMicrotask,
13978
13936
  scheduleTimeout: typeof setTimeout === "function" ? setTimeout : void 0,
13979
13937
  cancelTimeout: typeof clearTimeout === "function" ? clearTimeout : void 0,
13980
13938
  noTimeout: -1,
@@ -14015,28 +13973,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
14015
13973
  },
14016
13974
  resolveUpdatePriority() {
14017
13975
  if (currentUpdatePriority !== NoEventPriority) return currentUpdatePriority;
14018
- switch (typeof window !== "undefined" && window.event?.type) {
14019
- case "click":
14020
- case "contextmenu":
14021
- case "dblclick":
14022
- case "dragenter":
14023
- case "dragleave":
14024
- case "drop":
14025
- case "pointercancel":
14026
- case "pointerdown":
14027
- case "pointerup":
14028
- return e;
14029
- case "dragover":
14030
- case "pointermove":
14031
- case "pointerout":
14032
- case "pointerover":
14033
- case "pointerenter":
14034
- case "pointerleave":
14035
- case "wheel":
14036
- return o;
14037
- default:
14038
- return r;
14039
- }
13976
+ const eventType = typeof window !== "undefined" ? window.event?.type : void 0;
13977
+ if (eventType === void 0) return r;
13978
+ return getEventPriority(eventType);
14040
13979
  },
14041
13980
  resetFormInstance() {
14042
13981
  },
@@ -14492,6 +14431,10 @@ function createRoot(canvas) {
14492
14431
  if (state2.internal.isMultiCanvas && state2.internal.canvasTarget) {
14493
14432
  const renderer2 = state2.internal.actualRenderer;
14494
14433
  renderer2.setCanvasTarget(state2.internal.canvasTarget);
14434
+ if (state2.internal.canvasTargetSizeDirty) {
14435
+ state2.internal.canvasTargetSizeDirty = false;
14436
+ renderer2.backend?.updateSize?.();
14437
+ }
14495
14438
  }
14496
14439
  },
14497
14440
  {
@@ -14648,7 +14591,8 @@ function unmountComponentAtNode(canvas, callback) {
14648
14591
  dispose(state.scene);
14649
14592
  _roots.delete(canvas);
14650
14593
  if (callback) callback(canvas);
14651
- } catch {
14594
+ } catch (error) {
14595
+ console.warn("[R3F] Error while unmounting root; teardown may be incomplete:", error);
14652
14596
  }
14653
14597
  }, 500);
14654
14598
  }
@@ -14759,6 +14703,212 @@ function flushSync(fn) {
14759
14703
  return reconciler.flushSyncFromReconciler(fn);
14760
14704
  }
14761
14705
 
14706
+ const isRef = (obj) => obj.current && obj.current.isScene;
14707
+ const resolveScene = (scene) => isRef(scene) ? scene.current : scene;
14708
+ function setEnvProps(background, scene, defaultScene, texture, sceneProps = {}) {
14709
+ sceneProps = {
14710
+ backgroundBlurriness: 0,
14711
+ backgroundIntensity: 1,
14712
+ backgroundRotation: [0, 0, 0],
14713
+ environmentIntensity: 1,
14714
+ environmentRotation: [0, 0, 0],
14715
+ ...sceneProps
14716
+ };
14717
+ const target = resolveScene(scene || defaultScene);
14718
+ const oldbg = target.background;
14719
+ const oldenv = target.environment;
14720
+ const oldSceneProps = {
14721
+ // @ts-ignore
14722
+ backgroundBlurriness: target.backgroundBlurriness,
14723
+ // @ts-ignore
14724
+ backgroundIntensity: target.backgroundIntensity,
14725
+ // @ts-ignore
14726
+ backgroundRotation: target.backgroundRotation?.clone?.() ?? [0, 0, 0],
14727
+ // @ts-ignore
14728
+ environmentIntensity: target.environmentIntensity,
14729
+ // @ts-ignore
14730
+ environmentRotation: target.environmentRotation?.clone?.() ?? [0, 0, 0]
14731
+ };
14732
+ if (background !== "only") target.environment = texture;
14733
+ if (background) target.background = texture;
14734
+ applyProps(target, sceneProps);
14735
+ return () => {
14736
+ if (background !== "only") target.environment = oldenv;
14737
+ if (background) target.background = oldbg;
14738
+ applyProps(target, oldSceneProps);
14739
+ };
14740
+ }
14741
+ function EnvironmentMap({ scene, background = false, map, ...config }) {
14742
+ const defaultScene = useThree((state) => state.scene);
14743
+ React.useLayoutEffect(() => {
14744
+ if (map) return setEnvProps(background, scene, defaultScene, map, config);
14745
+ });
14746
+ return null;
14747
+ }
14748
+ function EnvironmentCube({
14749
+ background = false,
14750
+ scene,
14751
+ blur,
14752
+ backgroundBlurriness,
14753
+ backgroundIntensity,
14754
+ backgroundRotation,
14755
+ environmentIntensity,
14756
+ environmentRotation,
14757
+ ...rest
14758
+ }) {
14759
+ const texture = useEnvironment(rest);
14760
+ const defaultScene = useThree((state) => state.scene);
14761
+ React.useLayoutEffect(() => {
14762
+ return setEnvProps(background, scene, defaultScene, texture, {
14763
+ backgroundBlurriness: blur ?? backgroundBlurriness,
14764
+ backgroundIntensity,
14765
+ backgroundRotation,
14766
+ environmentIntensity,
14767
+ environmentRotation
14768
+ });
14769
+ });
14770
+ React.useEffect(() => {
14771
+ return () => {
14772
+ texture.dispose();
14773
+ };
14774
+ }, [texture]);
14775
+ return null;
14776
+ }
14777
+ function EnvironmentPortal({
14778
+ children,
14779
+ near = 0.1,
14780
+ far = 1e3,
14781
+ resolution = 256,
14782
+ frames = 1,
14783
+ map,
14784
+ background = false,
14785
+ blur,
14786
+ backgroundBlurriness,
14787
+ backgroundIntensity,
14788
+ backgroundRotation,
14789
+ environmentIntensity,
14790
+ environmentRotation,
14791
+ scene,
14792
+ files,
14793
+ path,
14794
+ preset = void 0,
14795
+ extensions
14796
+ }) {
14797
+ const renderer = useThree((state) => state.renderer);
14798
+ const isLegacy = useThree((state) => state.isLegacy);
14799
+ const defaultScene = useThree((state) => state.scene);
14800
+ const camera = React.useRef(null);
14801
+ const [virtualScene] = React.useState(() => new Scene());
14802
+ const fbo = React.useMemo(() => {
14803
+ const fbo2 = isLegacy ? new WebGLCubeRenderTarget(resolution) : new CubeRenderTarget(resolution);
14804
+ fbo2.texture.type = HalfFloatType;
14805
+ return fbo2;
14806
+ }, [resolution, isLegacy]);
14807
+ React.useEffect(() => {
14808
+ return () => {
14809
+ fbo.dispose();
14810
+ };
14811
+ }, [fbo]);
14812
+ React.useLayoutEffect(() => {
14813
+ if (frames === 1) {
14814
+ const autoClear = renderer.autoClear;
14815
+ renderer.autoClear = true;
14816
+ camera.current.update(renderer, virtualScene);
14817
+ renderer.autoClear = autoClear;
14818
+ }
14819
+ return setEnvProps(background, scene, defaultScene, fbo.texture, {
14820
+ backgroundBlurriness: blur ?? backgroundBlurriness,
14821
+ backgroundIntensity,
14822
+ backgroundRotation,
14823
+ environmentIntensity,
14824
+ environmentRotation
14825
+ });
14826
+ }, [
14827
+ children,
14828
+ virtualScene,
14829
+ fbo.texture,
14830
+ scene,
14831
+ defaultScene,
14832
+ background,
14833
+ frames,
14834
+ renderer,
14835
+ blur,
14836
+ backgroundBlurriness,
14837
+ backgroundIntensity,
14838
+ backgroundRotation,
14839
+ environmentIntensity,
14840
+ environmentRotation
14841
+ ]);
14842
+ let count = 1;
14843
+ useFrame(() => {
14844
+ if (frames === Infinity || count < frames) {
14845
+ const autoClear = renderer.autoClear;
14846
+ renderer.autoClear = true;
14847
+ camera.current.update(renderer, virtualScene);
14848
+ renderer.autoClear = autoClear;
14849
+ count++;
14850
+ }
14851
+ });
14852
+ return /* @__PURE__ */ jsx(Fragment, { children: createPortal(
14853
+ /* @__PURE__ */ jsxs(Fragment, { children: [
14854
+ children,
14855
+ /* @__PURE__ */ jsx("cubeCamera", { ref: camera, args: [near, far, fbo] }),
14856
+ files || preset ? /* @__PURE__ */ jsx(EnvironmentCube, { background: true, files, preset, path, extensions }) : map ? /* @__PURE__ */ jsx(EnvironmentMap, { background: true, map, extensions }) : null
14857
+ ] }),
14858
+ virtualScene
14859
+ ) });
14860
+ }
14861
+ function EnvironmentGround(props) {
14862
+ const textureDefault = useEnvironment(props);
14863
+ const texture = props.map || textureDefault;
14864
+ React.useMemo(() => extend({ GroundProjectedEnvImpl: GroundedSkybox }), []);
14865
+ React.useEffect(() => {
14866
+ return () => {
14867
+ textureDefault.dispose();
14868
+ };
14869
+ }, [textureDefault]);
14870
+ const height = props.ground?.height ?? 15;
14871
+ const radius = props.ground?.radius ?? 60;
14872
+ const scale = props.ground?.scale ?? 1e3;
14873
+ const args = React.useMemo(
14874
+ () => [texture, height, radius],
14875
+ [texture, height, radius]
14876
+ );
14877
+ return /* @__PURE__ */ jsxs(Fragment, { children: [
14878
+ /* @__PURE__ */ jsx(EnvironmentMap, { ...props, map: texture }),
14879
+ /* @__PURE__ */ jsx("groundProjectedEnvImpl", { args, scale })
14880
+ ] });
14881
+ }
14882
+ function EnvironmentColor({ color, scene }) {
14883
+ const defaultScene = useThree((state) => state.scene);
14884
+ React.useLayoutEffect(() => {
14885
+ if (color === void 0) return;
14886
+ const target = resolveScene(scene || defaultScene);
14887
+ const oldBg = target.background;
14888
+ target.background = new Color(color);
14889
+ return () => {
14890
+ target.background = oldBg;
14891
+ };
14892
+ });
14893
+ return null;
14894
+ }
14895
+ function EnvironmentDualSource(props) {
14896
+ const { backgroundFiles, ...envProps } = props;
14897
+ return /* @__PURE__ */ jsxs(Fragment, { children: [
14898
+ /* @__PURE__ */ jsx(EnvironmentCube, { ...envProps, background: false }),
14899
+ /* @__PURE__ */ jsx(EnvironmentCube, { ...props, files: backgroundFiles, background: "only" })
14900
+ ] });
14901
+ }
14902
+ function Environment(props) {
14903
+ if (props.color && !props.files && !props.preset && !props.map) {
14904
+ return /* @__PURE__ */ jsx(EnvironmentColor, { ...props });
14905
+ }
14906
+ if (props.backgroundFiles && props.backgroundFiles !== props.files) {
14907
+ return /* @__PURE__ */ jsx(EnvironmentDualSource, { ...props });
14908
+ }
14909
+ return props.ground ? /* @__PURE__ */ jsx(EnvironmentGround, { ...props }) : props.map ? /* @__PURE__ */ jsx(EnvironmentMap, { ...props }) : props.children ? /* @__PURE__ */ jsx(EnvironmentPortal, { ...props }) : /* @__PURE__ */ jsx(EnvironmentCube, { ...props });
14910
+ }
14911
+
14762
14912
  function parseBackground(background) {
14763
14913
  if (!background) return null;
14764
14914
  if (typeof background === "object" && !background.isColor) {
@@ -14802,14 +14952,36 @@ function parseRendererConfig(rendererProp) {
14802
14952
  return { primaryCanvas: void 0, scheduler: void 0, renderer: rendererProp };
14803
14953
  }
14804
14954
 
14955
+ const RESOURCE_KINDS = ["nodes", "uniforms", "buffers", "gpuStorage"];
14956
+ const registries = /* @__PURE__ */ new WeakMap();
14957
+ function getKindRegistry(store, kind) {
14958
+ let registry = registries.get(store);
14959
+ if (!registry) {
14960
+ registry = {
14961
+ nodes: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
14962
+ uniforms: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
14963
+ buffers: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
14964
+ gpuStorage: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() }
14965
+ };
14966
+ registries.set(store, registry);
14967
+ }
14968
+ return registry[kind];
14969
+ }
14970
+ function invalidateResource(store, kind, scopeKey) {
14971
+ const registry = getKindRegistry(store, kind);
14972
+ {
14973
+ registry.valid.clear();
14974
+ registry.staged.clear();
14975
+ }
14976
+ }
14977
+ function invalidateAllResources(store) {
14978
+ for (const kind of RESOURCE_KINDS) invalidateResource(store, kind);
14979
+ }
14980
+
14805
14981
  function clearHmrCaches(store) {
14806
- store.setState((state) => ({
14807
- nodes: {},
14808
- uniforms: {},
14809
- buffers: {},
14810
- gpuStorage: {},
14811
- _hmrVersion: state._hmrVersion + 1
14812
- }));
14982
+ const primary = store.getState().primaryStore ?? store;
14983
+ invalidateAllResources(primary);
14984
+ primary.setState((state) => ({ _hmrVersion: state._hmrVersion + 1 }));
14813
14985
  }
14814
14986
 
14815
14987
  function CanvasImpl({
@@ -14946,7 +15118,7 @@ function CanvasImpl({
14946
15118
  onDropMissed: (...args) => handleDropMissed.current?.(...args),
14947
15119
  onCreated: (state) => {
14948
15120
  state.events.connect?.(
14949
- eventSource ? isRef(eventSource) ? eventSource.current : eventSource : divRef.current
15121
+ eventSource ? isRef$1(eventSource) ? eventSource.current : eventSource : divRef.current
14950
15122
  );
14951
15123
  if (eventPrefix) {
14952
15124
  state.setEvents({
@@ -15059,4 +15231,4 @@ function Canvas(props) {
15059
15231
 
15060
15232
  extend(THREE);
15061
15233
 
15062
- 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 };
15234
+ 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$1 as isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, removeInteractivity, resolve, swapInteractivity, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };