@react-three/fiber 10.0.0-canary.3f8df2b → 10.0.0-canary.42caa10

package/dist/shared/fiber.BzEJI6VE.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+const Canvas = require('./fiber.C2WmwvFB.cjs');
+const textureStaging = require('./fiber.BO8-26r8.cjs');
+
+const useThree = textureStaging.useThree;
+const useFrame = textureStaging.useFrame;
+const useRenderTarget = Canvas.useRenderTarget;
+const asWebGPUCanvas = (Canvas) => Canvas;
+
+exports.asWebGPUCanvas = asWebGPUCanvas;
+exports.useFrame = useFrame;
+exports.useRenderTarget = useRenderTarget;
+exports.useThree = useThree;

package/dist/shared/{fiber.B0oukOFO.mjs → fiber.C-3TIsF8.mjs}

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';
-import { useFiber, useContextBridge, traverseFiber } from 'its-fine';
+import { useFiber, useContextBridge, useActivityBridge as useActivityBridge$1, traverseFiber } from 'its-fine';
 import { getScheduler } from '@pmndrs/scheduler';
 
 var __defProp = Object.defineProperty;
@@ -13,16 +13,18 @@ function useMutableCallback(fn) {
   useIsomorphicLayoutEffect(() => void (ref.current = fn), [fn]);
   return ref;
 }
+const useActivityBridge = React["Activity"] ? useActivityBridge$1 : () => React.Fragment;
 function useBridge() {
   const fiber = useFiber();
   const ContextBridge = useContextBridge();
+  const ActivityBridge = useActivityBridge();
   return React.useMemo(
     () => ({ children }) => {
       const strict = !!traverseFiber(fiber, true, (node) => node.type === React.StrictMode);
       const Root = strict ? React.StrictMode : React.Fragment;
-      return /* @__PURE__ */ jsx(Root, { children: /* @__PURE__ */ jsx(ContextBridge, { children }) });
+      return /* @__PURE__ */ jsx(Root, { children: /* @__PURE__ */ jsx(ActivityBridge, { children: /* @__PURE__ */ jsx(ContextBridge, { children }) }) });
     },
-    [fiber, ContextBridge]
+    [fiber, ContextBridge, ActivityBridge]
   );
 }
 function Block({ set }) {
@@ -47,6 +49,23 @@ const ErrorBoundary = /* @__PURE__ */ (() => {
     }
   }, __publicField(_a, "getDerivedStateFromError", () => ({ error: true })), _a;
 })();
+const noop = () => {
+};
+function Gate({ promise, onSettled }) {
+  React.use(promise);
+  useIsomorphicLayoutEffect(onSettled, [onSettled]);
+  return null;
+}
+function useGate() {
+  const [promise, setPromise] = React.useState(null);
+  const onSettled = React.useCallback(() => setPromise(null), []);
+  const waitFor = React.useCallback(
+    (next) => setPromise((current) => current ?? Promise.resolve(next).then(noop, noop)),
+    []
+  );
+  const gate = promise ? /* @__PURE__ */ jsx(React.Suspense, { fallback: null, children: /* @__PURE__ */ jsx(Gate, { promise, onSettled }) }) : null;
+  return [gate, waitFor];
+}
 
 const shownNotices = /* @__PURE__ */ new Set();
 function notifyDepreciated({ heading, body, link }) {
@@ -104,10 +123,179 @@ function notifyAlpha({ message, link }) {
     console.log(`%cMore info: ${link}`, "color: #6366f1; font-weight: normal;");
   }
 }
+function isDevelopment() {
+  try {
+    return process.env.NODE_ENV !== "production";
+  } catch {
+    return true;
+  }
+}
+
+const INTERNAL_LIB_MARKERS = [
+  "zustand",
+  "setState",
+  "Object.assign",
+  "@pmndrs/scheduler",
+  "Scheduler.tickRoot",
+  "Scheduler.stepJob"
+];
+function isInternalRendererAccess(stack, callerDepth = 2) {
+  if (!stack) return false;
+  const caller = stack.split("\n")[callerDepth] ?? "";
+  return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m));
+}
+
+const isAccessorDescriptor = (descriptor) => !!descriptor && (descriptor.get !== void 0 || descriptor.set !== void 0);
+const isAccessor = (object, key) => isAccessorDescriptor(Object.getOwnPropertyDescriptor(object, key));
+function cloneState(...sources) {
+  const target = {};
+  for (const source of sources) {
+    if (source) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+  }
+  return target;
+}
+function preserveAccessors(rawSet, get) {
+  return ((partial, replace) => {
+    const previous = get();
+    const patch = typeof partial === "function" ? partial(previous) : partial;
+    if (replace || !previous || patch == null || Object.is(patch, previous)) {
+      return rawSet(patch, replace);
+    }
+    const next = cloneState(previous);
+    const viaSetter = [];
+    for (const key of Reflect.ownKeys(patch)) {
+      const descriptor = Object.getOwnPropertyDescriptor(patch, key);
+      if (!descriptor.enumerable) continue;
+      if (isAccessorDescriptor(descriptor)) {
+        Object.defineProperty(next, key, descriptor);
+      } else if (isAccessor(next, key)) {
+        viaSetter.push(key);
+      } else {
+        Object.defineProperty(next, key, {
+          value: descriptor.value,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    for (const key of viaSetter) next[key] = patch[key];
+    rawSet(next, true);
+  });
+}
+const keepAccessors = (initializer) => (rawSet, get, api) => {
+  const set = preserveAccessors(rawSet, get);
+  api.setState = set;
+  return initializer(set, get, api);
+};
+let glNoticeShown = false;
+const schedulerViews = /* @__PURE__ */ new WeakMap();
+function stateForScheduler(state) {
+  let view = schedulerViews.get(state);
+  if (!view) {
+    view = cloneState(state);
+    Object.defineProperty(view, "gl", {
+      get() {
+        return this.internal?.actualRenderer;
+      },
+      set(value) {
+        this.internal.actualRenderer = value;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    schedulerViews.set(state, view);
+  }
+  return view;
+}
+function defineRendererAccessors(state) {
+  Object.defineProperty(state, "gl", {
+    get() {
+      const renderer = this.internal?.actualRenderer;
+      if (!glNoticeShown && renderer && !this.isLegacy) {
+        const stack = new Error().stack || "";
+        if (!isInternalRendererAccess(stack)) {
+          glNoticeShown = true;
+          const cleanedStack = stack.split("\n").slice(2).join("\n") || "Stack trace unavailable";
+          notifyDepreciated({
+            heading: "Accessing state.gl in WebGPU mode",
+            body: "Please use state.renderer instead. state.gl is deprecated and will be removed in future versions.\n\nFor backwards compatibility, state.gl currently maps to state.renderer, but this may cause issues with libraries expecting WebGLRenderer.\n\nAccessed from:\n" + cleanedStack
+          });
+        }
+      }
+      return renderer;
+    },
+    set(value) {
+      this.internal.actualRenderer = value;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(state, "renderer", {
+    get() {
+      return this.internal?.actualRenderer;
+    },
+    set(value) {
+      this.internal.actualRenderer = value;
+    },
+    enumerable: true,
+    configurable: true
+  });
+}
 
 const R3F_CONTEXT = Symbol.for("@react-three/fiber.context");
 const context = globalThis[R3F_CONTEXT] ?? (globalThis[R3F_CONTEXT] = React.createContext(null));
 
+const R3F_EXTENSIONS = Symbol.for("@react-three/fiber.extensions");
+function getRegistry() {
+  return globalThis[R3F_EXTENSIONS] ?? (globalThis[R3F_EXTENSIONS] = {
+    extensions: /* @__PURE__ */ new Map(),
+    roots: /* @__PURE__ */ new Set(),
+    applied: /* @__PURE__ */ new WeakMap()
+  });
+}
+function setupRoot(registry, store, extension) {
+  let applied = registry.applied.get(store);
+  if (!applied) registry.applied.set(store, applied = /* @__PURE__ */ new Map());
+  if (applied.has(extension.name)) return;
+  applied.set(extension.name, extension);
+  const patch = extension.setup?.(store);
+  if (patch) store.setState(patch);
+}
+function registerRootExtension(extension) {
+  const registry = getRegistry();
+  registry.extensions.set(extension.name, extension);
+  for (const store of registry.roots) setupRoot(registry, store, extension);
+  return () => {
+    if (registry.extensions.get(extension.name) === extension) registry.extensions.delete(extension.name);
+  };
+}
+function setRenderOverride(store, render) {
+  store.getState().internal.renderOverride = render;
+}
+function attachRootExtensions(store) {
+  const registry = getRegistry();
+  registry.roots.add(store);
+  for (const extension of registry.extensions.values()) setupRoot(registry, store, extension);
+}
+function current(registry, setUpBy) {
+  return registry.extensions.get(setUpBy.name) ?? setUpBy;
+}
+function detachRootExtensions(store) {
+  const registry = getRegistry();
+  if (!registry.roots.delete(store)) return;
+  const applied = registry.applied.get(store);
+  registry.applied.delete(store);
+  if (!applied) return;
+  for (const setUpBy of applied.values()) current(registry, setUpBy).dispose?.(store);
+}
+function notifyRootExtensionsHmr(store) {
+  const registry = getRegistry();
+  const applied = registry.applied.get(store);
+  if (!applied) return;
+  for (const setUpBy of applied.values()) current(registry, setUpBy).hmr?.(store);
+}
+
 function useStore() {
   const store = useContext(context);
   if (!store) throw new Error("R3F: Hooks can only be used within the Canvas component!");
@@ -134,8 +322,8 @@ function useFrame(callback, priorityOrOptions) {
   const options = React.useMemo(() => {
     return typeof priorityOrOptions === "number" ? { priority: priorityOrOptions } : priorityOrOptions ?? {};
   }, [optionsKey]);
-  const reactId = React.useId();
-  const id = options.id ?? reactId;
+  const [generatedId] = React.useState(() => scheduler.generateJobId());
+  const id = options.id ?? generatedId;
   const callbackRef = useMutableCallback(callback);
   const isLegacyPriority = typeof priorityOrOptions === "number" && priorityOrOptions > 0;
   const isLegacyOrdering = typeof priorityOrOptions === "number" && priorityOrOptions < 0;
@@ -166,14 +354,12 @@ function useFrame(callback, priorityOrOptions) {
         });
       }
       const wrappedCallback = (frameState, delta) => {
-        const localState = store.getState();
-        const mergedState = {
-          ...localState,
-          time: frameState.time,
-          delta: frameState.delta,
-          elapsed: frameState.elapsed,
-          frame: frameState.frame
-        };
+        const mergedState = cloneState(store.getState());
+        mergedState.time = frameState.time;
+        mergedState.delta = frameState.delta;
+        mergedState.elapsed = frameState.elapsed;
+        mergedState.frame = frameState.frame;
+        mergedState.overstep = frameState.overstep;
         callbackRef.current?.(mergedState, delta);
       };
       const unregister = scheduler.register(wrappedCallback, {
@@ -311,54 +497,4 @@ function getTextureView(store) {
   return view;
 }
 
-const R3F_EXTENSIONS = Symbol.for("@react-three/fiber.extensions");
-function getRegistry() {
-  return globalThis[R3F_EXTENSIONS] ?? (globalThis[R3F_EXTENSIONS] = {
-    extensions: /* @__PURE__ */ new Map(),
-    roots: /* @__PURE__ */ new Set(),
-    applied: /* @__PURE__ */ new WeakMap()
-  });
-}
-function setupRoot(registry, store, extension) {
-  let applied = registry.applied.get(store);
-  if (!applied) registry.applied.set(store, applied = /* @__PURE__ */ new Map());
-  if (applied.has(extension.name)) return;
-  applied.set(extension.name, extension);
-  const patch = extension.setup?.(store);
-  if (patch) store.setState(patch);
-}
-function registerRootExtension(extension) {
-  const registry = getRegistry();
-  registry.extensions.set(extension.name, extension);
-  for (const store of registry.roots) setupRoot(registry, store, extension);
-  return () => {
-    if (registry.extensions.get(extension.name) === extension) registry.extensions.delete(extension.name);
-  };
-}
-function setRenderOverride(store, render) {
-  store.getState().internal.renderOverride = render;
-}
-function attachRootExtensions(store) {
-  const registry = getRegistry();
-  registry.roots.add(store);
-  for (const extension of registry.extensions.values()) setupRoot(registry, store, extension);
-}
-function current(registry, setUpBy) {
-  return registry.extensions.get(setUpBy.name) ?? setUpBy;
-}
-function detachRootExtensions(store) {
-  const registry = getRegistry();
-  if (!registry.roots.delete(store)) return;
-  const applied = registry.applied.get(store);
-  registry.applied.delete(store);
-  if (!applied) return;
-  for (const setUpBy of applied.values()) current(registry, setUpBy).dispose?.(store);
-}
-function notifyRootExtensionsHmr(store) {
-  const registry = getRegistry();
-  const applied = registry.applied.get(store);
-  if (!applied) return;
-  for (const setUpBy of applied.values()) current(registry, setUpBy).hmr?.(store);
-}
-
-export { Block as B, ErrorBoundary as E, useThree as a, useFrame as b, context as c, useIsomorphicLayoutEffect as d, useMutableCallback as e, useBridge as f, getTextureView as g, unstageTextures as h, stageTextures as i, detachRootExtensions as j, attachRootExtensions as k, notifyAlpha as l, notifyRootExtensionsHmr as m, notifyDepreciated as n, registerRootExtension as r, setRenderOverride as s, useStore as u };
+export { Block as B, ErrorBoundary as E, useThree as a, useFrame as b, context as c, useIsomorphicLayoutEffect as d, useMutableCallback as e, useBridge as f, getTextureView as g, defineRendererAccessors as h, isDevelopment as i, stateForScheduler as j, detachRootExtensions as k, attachRootExtensions as l, unstageTextures as m, notifyDepreciated as n, stageTextures as o, preserveAccessors as p, isAccessor as q, registerRootExtension as r, setRenderOverride as s, cloneState as t, useStore as u, keepAccessors as v, useGate as w, notifyAlpha as x, notifyRootExtensionsHmr as y };