@gnsx/react-three-fiber 10.0.2 → 10.0.4

package/dist/webgpu/index.mjs

@@ -3440,7 +3440,7 @@ function advance(timestamp) {
   getScheduler().step(timestamp);
 }
 
-const version = "10.0.1";
+const version = "10.0.4";
 const packageData = {
 	version: version};
 
@@ -15197,6 +15197,7 @@ function createRoot(canvas) {
   let pending = null;
   return {
     async configure(props = {}) {
+      if (pending) await pending;
       let resolve;
       pending = new Promise((_resolve) => resolve = _resolve);
       const {
@@ -15475,8 +15476,10 @@ function createRoot(canvas) {
         const unregisterCanvasTarget = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             if (state2.internal.isMultiCanvas && state2.internal.canvasTarget) {
               const renderer2 = state2.internal.actualRenderer;
+              if (!renderer2) return;
               renderer2.setCanvasTarget(state2.internal.canvasTarget);
             }
           },
@@ -15529,7 +15532,9 @@ function createRoot(canvas) {
         const unregisterRender = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             const renderer2 = state2.internal.actualRenderer;
+            if (!renderer2) return;
             const userHandlesRender = scheduler.hasUserJobsInPhase("render", newRootId);
             if (userHandlesRender || state2.internal.priority) return;
             try {
@@ -15604,23 +15609,62 @@ function Provider({
   }, []);
   return /* @__PURE__ */ jsx(context.Provider, { value: store, children });
 }
+function releaseSceneR3fLinks(scene, options) {
+  if (!scene) return null;
+  scene.traverse((obj) => {
+    delete obj.__r3f;
+  });
+  delete scene.__r3f;
+  {
+    scene.clear();
+  }
+  return scene;
+}
+function releaseRendererRefsFromRootState(state) {
+  const { internal } = state;
+  const renderer = internal.actualRenderer ?? null;
+  internal.actualRenderer = null;
+  internal.canvasTarget = null;
+  internal.pointerMap?.clear();
+  internal.pointerDirty?.clear();
+  return renderer;
+}
+function detachRootSceneFromRootState(state) {
+  const scene = releaseSceneR3fLinks(state.scene);
+  state.set((prev) => ({
+    scene: null,
+    rootScene: null,
+    internal: { ...prev.internal, container: null }
+  }));
+  return scene;
+}
 function unmountComponentAtNode(canvas, callback) {
   const root = _roots.get(canvas);
   const fiber = root?.fiber;
   if (fiber) {
     const state = root?.store.getState();
-    if (state) state.internal.active = false;
+    let rendererForCleanup = null;
+    let canvasTargetForCleanup;
+    let sceneForCleanup = null;
+    if (state) {
+      state.internal.active = false;
+      canvasTargetForCleanup = state.internal.canvasTarget;
+      rendererForCleanup = releaseRendererRefsFromRootState(state);
+      const unregisterRoot = state.internal.unregisterRoot;
+      if (unregisterRoot) {
+        unregisterRoot();
+        state.internal.unregisterRoot = void 0;
+      }
+    }
     reconciler.updateContainer(null, fiber, null, () => {
       if (state) {
+        sceneForCleanup = detachRootSceneFromRootState(state);
         setTimeout(() => {
           try {
-            const renderer = state.internal.actualRenderer;
-            const unregisterRoot = state.internal.unregisterRoot;
-            if (unregisterRoot) unregisterRoot();
+            const renderer = rendererForCleanup;
             const unregisterPrimary = state.internal.unregisterPrimary;
             if (unregisterPrimary) unregisterPrimary();
-            const canvasTarget = state.internal.canvasTarget;
-            if (canvasTarget?.dispose) canvasTarget.dispose();
+            if (canvasTargetForCleanup?.dispose) canvasTargetForCleanup.dispose();
             state.events.disconnect?.();
             cleanupHelperGroup(root.store);
             if (state.isLegacy && renderer) {
@@ -15631,7 +15675,7 @@ function unmountComponentAtNode(canvas, callback) {
             if (!state.internal.isSecondary) {
               if (renderer?.xr) state.xr.disconnect();
             }
-            dispose(state.scene);
+            if (sceneForCleanup) dispose(sceneForCleanup);
             _roots.delete(canvas);
             if (callback) callback(canvas);
           } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gnsx/react-three-fiber",
-  "version": "10.0.2",
+  "version": "10.0.4",
   "description": "A React renderer for Threejs",
   "keywords": [
     "react",

package/react-reconciler/constants.d.ts

@@ -1,7 +1,7 @@
-export const DiscreteEventPriority = 0b0000000000000000000000000000001;
-export const ContinuousEventPriority = 0b0000000000000000000000000000100;
-export const DefaultEventPriority = 0b0000000000000000000000000010000;
-export const IdleEventPriority = 0b0100000000000000000000000000000;
-export const LegacyRoot = 0;
-export const ConcurrentRoot = 1;
-export const NoEventPriority = 0;
+export const DiscreteEventPriority = 0b0000000000000000000000000000001;
+export const ContinuousEventPriority = 0b0000000000000000000000000000100;
+export const DefaultEventPriority = 0b0000000000000000000000000010000;
+export const IdleEventPriority = 0b0100000000000000000000000000000;
+export const LegacyRoot = 0;
+export const ConcurrentRoot = 1;
+export const NoEventPriority = 0;