@isograph/react-disposable-state 0.0.0-main-1cd3db6d → 0.0.0-main-dda53d04

package/src/useCachedPrecommitValue.test.tsx

@@ -1,10 +1,10 @@
-import { describe, test, vi, expect, assert } from "vitest";
-import { ParentCache } from "./ParentCache";
-import { ItemCleanupPair } from "@isograph/disposable-types";
-import { useCachedPrecommitValue } from "./useCachedPrecommitValue";
-import React from "react";
-import { create } from "react-test-renderer";
-import { CacheItem, CacheItemState } from "./CacheItem";
+import { describe, test, vi, expect, assert } from 'vitest';
+import { ParentCache } from './ParentCache';
+import { ItemCleanupPair } from '@isograph/disposable-types';
+import { useCachedPrecommitValue } from './useCachedPrecommitValue';
+import React from 'react';
+import { create } from 'react-test-renderer';
+import { CacheItem, CacheItemState } from './CacheItem';
 
 function getItem<T>(cache: ParentCache<T>): CacheItem<T> | null {
   return (cache as any).__item;
@@ -52,26 +52,20 @@ function promiseAndResolver() {
 // The fact that sometimes we need to render in concurrent mode and sometimes
 // not is a bit worrisome.
 async function awaitableCreate(Component, isConcurrent) {
-  const element = create(
-    Component,
-    isConcurrent ? { unstable_isConcurrent: true } : undefined
-  );
+  const element = create(Component, isConcurrent ? { unstable_isConcurrent: true } : undefined);
   await shortPromise();
   return element;
 }
 
-describe("useCachedPrecommitValue", () => {
-  test("on initial render, it should call getOrPopulateAndTemporaryRetain", async () => {
+describe('useCachedPrecommitValue', () => {
+  test('on initial render, it should call getOrPopulateAndTemporaryRetain', async () => {
     const disposeItem = vi.fn();
     const factory = vi.fn(() => {
       const pair: ItemCleanupPair<number> = [1, disposeItem];
       return pair;
     });
     const cache = new ParentCache(factory);
-    const getOrPopulateAndTemporaryRetain = vi.spyOn(
-      cache,
-      "getOrPopulateAndTemporaryRetain"
-    );
+    const getOrPopulateAndTemporaryRetain = vi.spyOn(cache, 'getOrPopulateAndTemporaryRetain');
 
     const componentCommits = vi.fn();
     const hookOnCommit = vi.fn();
@@ -103,7 +97,7 @@ describe("useCachedPrecommitValue", () => {
     expect(render).toHaveBeenCalledTimes(1);
   });
 
-  test("on commit, it should call the provided callback and empty the parent cache", async () => {
+  test('on commit, it should call the provided callback and empty the parent cache', async () => {
     const disposeItem = vi.fn();
     const factory = vi.fn(() => {
       const pair: ItemCleanupPair<number> = [1, disposeItem];
@@ -124,7 +118,7 @@ describe("useCachedPrecommitValue", () => {
         expect(componentCommits).toHaveBeenCalledTimes(1);
         expect(hookOnCommit).toBeCalledTimes(1);
         expect(hookOnCommit.mock.calls[0][0][0]).toBe(1);
-        expect(typeof hookOnCommit.mock.calls[0][0][1]).toBe("function");
+        expect(typeof hookOnCommit.mock.calls[0][0][1]).toBe('function');
         expect(factory).toBeCalledTimes(1);
         expect(disposeItem).not.toBeCalled();
         expect(cache.isEmpty()).toBe(true);
@@ -140,7 +134,7 @@ describe("useCachedPrecommitValue", () => {
     expect(render).toHaveBeenCalledTimes(1);
   });
 
-  test("after commit, on subsequent renders it should return null", async () => {
+  test('after commit, on subsequent renders it should return null', async () => {
     const disposeItem = vi.fn();
     const factory = vi.fn(() => {
       const pair: ItemCleanupPair<number> = [1, disposeItem];
@@ -186,8 +180,8 @@ describe("useCachedPrecommitValue", () => {
   });
 
   test(
-    "on repeated pre-commit renders, if the temporary retain is not disposed, " +
-      "it should re-call getOrPopulateAndTemporaryRetain but not call factory again",
+    'on repeated pre-commit renders, if the temporary retain is not disposed, ' +
+      'it should re-call getOrPopulateAndTemporaryRetain but not call factory again',
     async () => {
       const disposeItem = vi.fn();
       const factory = vi.fn(() => {
@@ -195,10 +189,7 @@ describe("useCachedPrecommitValue", () => {
         return pair;
       });
       const cache = new ParentCache(factory);
-      const getOrPopulateAndTemporaryRetain = vi.spyOn(
-        cache,
-        "getOrPopulateAndTemporaryRetain"
-      );
+      const getOrPopulateAndTemporaryRetain = vi.spyOn(cache, 'getOrPopulateAndTemporaryRetain');
 
       const componentCommits = vi.fn();
       const hookOnCommit = vi.fn();
@@ -212,9 +203,7 @@ describe("useCachedPrecommitValue", () => {
         expect(factory).toHaveBeenCalledTimes(1);
 
         renderCount++;
-        expect(getOrPopulateAndTemporaryRetain).toHaveBeenCalledTimes(
-          renderCount
-        );
+        expect(getOrPopulateAndTemporaryRetain).toHaveBeenCalledTimes(renderCount);
 
         React.useEffect(() => {
           componentCommits();
@@ -233,7 +222,7 @@ describe("useCachedPrecommitValue", () => {
           <TestComponent />
           <Suspender promise={promise} isResolvedRef={isResolvedRef} />
         </React.Suspense>,
-        true
+        true,
       );
 
       expect(componentCommits).toHaveBeenCalledTimes(0);
@@ -244,12 +233,12 @@ describe("useCachedPrecommitValue", () => {
 
       expect(componentCommits).toHaveBeenCalledTimes(1);
       expect(render).toHaveBeenCalledTimes(2);
-    }
+    },
   );
 
   test(
-    "on repeated pre-commit renders, if the temporary retain is disposed, " +
-      "it should re-call getOrPopulateAndTemporaryRetain and factory",
+    'on repeated pre-commit renders, if the temporary retain is disposed, ' +
+      'it should re-call getOrPopulateAndTemporaryRetain and factory',
     async () => {
       const disposeItem = vi.fn();
       let factoryValue = 0;
@@ -260,10 +249,7 @@ describe("useCachedPrecommitValue", () => {
       });
       const cache = new ParentCache(factory);
 
-      const getOrPopulateAndTemporaryRetain = vi.spyOn(
-        cache,
-        "getOrPopulateAndTemporaryRetain"
-      );
+      const getOrPopulateAndTemporaryRetain = vi.spyOn(cache, 'getOrPopulateAndTemporaryRetain');
 
       const componentCommits = vi.fn();
       const hookOnCommit = vi.fn();
@@ -305,7 +291,7 @@ describe("useCachedPrecommitValue", () => {
           <TestComponent />
           <Suspender promise={promise} isResolvedRef={isResolvedRef} />
         </React.Suspense>,
-        true
+        true,
       );
 
       expect(componentCommits).toHaveBeenCalledTimes(0);
@@ -316,13 +302,13 @@ describe("useCachedPrecommitValue", () => {
 
       expect(componentCommits).toHaveBeenCalledTimes(1);
       expect(render).toHaveBeenCalledTimes(2);
-    }
+    },
   );
 
   test(
-    "if the item has been disposed between the render and the commit, " +
-      "and the parent cache is empty, it will call factory again, re-render an " +
-      "additional time and called onCommit with the newly generated item",
+    'if the item has been disposed between the render and the commit, ' +
+      'and the parent cache is empty, it will call factory again, re-render an ' +
+      'additional time and called onCommit with the newly generated item',
     async () => {
       const disposeItem = vi.fn();
       let factoryCount = 0;
@@ -332,14 +318,8 @@ describe("useCachedPrecommitValue", () => {
         return pair;
       });
       const cache = new ParentCache(factory);
-      const getOrPopulateAndTemporaryRetain = vi.spyOn(
-        cache,
-        "getOrPopulateAndTemporaryRetain"
-      );
-      const getAndPermanentRetainIfPresent = vi.spyOn(
-        cache,
-        "getAndPermanentRetainIfPresent"
-      );
+      const getOrPopulateAndTemporaryRetain = vi.spyOn(cache, 'getOrPopulateAndTemporaryRetain');
+      const getAndPermanentRetainIfPresent = vi.spyOn(cache, 'getAndPermanentRetainIfPresent');
 
       const componentCommits = vi.fn();
       const hookOnCommit = vi.fn();
@@ -353,9 +333,7 @@ describe("useCachedPrecommitValue", () => {
           componentCommits();
           expect(getOrPopulateAndTemporaryRetain).toHaveBeenCalledTimes(1);
           expect(getAndPermanentRetainIfPresent).toHaveBeenCalledTimes(1);
-          expect(getAndPermanentRetainIfPresent.mock.results[0].value).toBe(
-            null
-          );
+          expect(getAndPermanentRetainIfPresent.mock.results[0].value).toBe(null);
           expect(factory).toHaveBeenCalledTimes(2);
           expect(cache.isEmpty()).toBe(true);
           expect(hookOnCommit).toHaveBeenCalledTimes(1);
@@ -402,20 +380,20 @@ describe("useCachedPrecommitValue", () => {
           <TestComponent />
           <CodeExecutor />
         </>,
-        false
+        false,
       );
 
       // This code executes after the commit and re-render of TestComponent.
       // The commit triggers a re-render, because the item was disposed.
       expect(render).toHaveBeenCalledTimes(2);
       expect(factory).toBeCalledTimes(2);
-    }
+    },
   );
 
   test(
-    "if, between the render and the commit, the item has been disposed, " +
-      "and the parent cache is not empty, it will not call factory again, will re-render " +
-      "an additional time and will call onCommit with the value in the parent cache",
+    'if, between the render and the commit, the item has been disposed, ' +
+      'and the parent cache is not empty, it will not call factory again, will re-render ' +
+      'an additional time and will call onCommit with the value in the parent cache',
     async () => {
       const disposeItem = vi.fn();
       let factoryCount = 0;
@@ -425,10 +403,7 @@ describe("useCachedPrecommitValue", () => {
         return pair;
       });
       const cache = new ParentCache(factory);
-      const getAndPermanentRetainIfPresent = vi.spyOn(
-        cache,
-        "getAndPermanentRetainIfPresent"
-      );
+      const getAndPermanentRetainIfPresent = vi.spyOn(cache, 'getAndPermanentRetainIfPresent');
 
       const componentCommits = vi.fn();
       const hookOnCommit = vi.fn();
@@ -442,9 +417,7 @@ describe("useCachedPrecommitValue", () => {
           // Note that we called getOrPopulateAndTemporaryRetain during CodeExecutor, hence 2
           expect(getOrPopulateAndTemporaryRetain).toHaveBeenCalledTimes(2);
           expect(getAndPermanentRetainIfPresent).toHaveBeenCalledTimes(1);
-          expect(getAndPermanentRetainIfPresent.mock.results[0].value[0]).toBe(
-            2
-          );
+          expect(getAndPermanentRetainIfPresent.mock.results[0].value[0]).toBe(2);
           expect(factory).toHaveBeenCalledTimes(2);
           expect(hookOnCommit).toHaveBeenCalledTimes(1);
           expect(hookOnCommit.mock.calls[0][0][0]).toBe(2);
@@ -453,10 +426,7 @@ describe("useCachedPrecommitValue", () => {
         return <div />;
       }
 
-      const getOrPopulateAndTemporaryRetain = vi.spyOn(
-        cache,
-        "getOrPopulateAndTemporaryRetain"
-      );
+      const getOrPopulateAndTemporaryRetain = vi.spyOn(cache, 'getOrPopulateAndTemporaryRetain');
 
       // wat is going on?
       //
@@ -499,7 +469,7 @@ describe("useCachedPrecommitValue", () => {
           <TestComponent />
           <CodeExecutor />
         </React.Suspense>,
-        false
+        false,
       );
 
       // This code executes after the commit and re-render of TestComponent.
@@ -508,13 +478,13 @@ describe("useCachedPrecommitValue", () => {
       // Note that this is the same number of calls as inside of CodeExecutor,
       // implying that the factory function was not called again.
       expect(factory).toBeCalledTimes(2);
-    }
+    },
   );
 
   test(
-    "If the component unmounts before committing, " +
-      "the item will remain in the parent cache, " +
-      "temporarily retained",
+    'If the component unmounts before committing, ' +
+      'the item will remain in the parent cache, ' +
+      'temporarily retained',
     async () => {
       const disposeItem = vi.fn();
       const factory = vi.fn(() => {
@@ -570,7 +540,7 @@ describe("useCachedPrecommitValue", () => {
         // If we're not in concurrent mode, TestComponent will mount before
         // unmounting. This perhaps is a bug in react-test-renderer. Regardless,
         // we're not interested in that scenario.
-        true
+        true,
       );
 
       // This code executes after the commit and re-render of TestComponent.
@@ -579,9 +549,9 @@ describe("useCachedPrecommitValue", () => {
       expect(componentCommits).toHaveBeenCalledTimes(0);
       const item = getItem(cache)!;
       const state = getState(item);
-      assert(state.kind === "InParentCacheAndNotDisposed");
+      assert(state.kind === 'InParentCacheAndNotDisposed');
       expect(state.permanentRetainCount).toBe(0);
       expect(state.temporaryRetainCount).toBe(1);
-    }
+    },
   );
 });

package/src/useCachedPrecommitValue.ts

@@ -1,9 +1,9 @@
-"use strict";
+'use strict';
 
-import { useEffect, useState } from "react";
-import { ParentCache } from "./ParentCache";
-import { useHasCommittedRef } from "./useHasCommittedRef";
-import { ItemCleanupPair } from "@isograph/isograph-disposable-types/dist";
+import { useEffect, useState } from 'react';
+import { ParentCache } from './ParentCache';
+import { useHasCommittedRef } from './useHasCommittedRef';
+import { ItemCleanupPair } from '@isograph/isograph-disposable-types/dist';
 
 /**
  * usePrecommitValue<T>
@@ -38,7 +38,7 @@ import { ItemCleanupPair } from "@isograph/isograph-disposable-types/dist";
  */
 export function useCachedPrecommitValue<T>(
   parentCache: ParentCache<T>,
-  onCommit: (pair: ItemCleanupPair<T>) => void
+  onCommit: (pair: ItemCleanupPair<T>) => void,
 ): { state: T } | null {
   // TODO: there should be two APIs. One in which we always re-render if the
   // committed item was not returned during the last render, and one in which
@@ -65,16 +65,13 @@ export function useCachedPrecommitValue<T>(
     //
     // After the above, we have a non-disposed item and a cleanup function, which we
     // can pass to onCommit.
-    const undisposedPair = cacheItem.permanentRetainIfNotDisposed(
-      disposeOfTemporaryRetain
-    );
+    const undisposedPair = cacheItem.permanentRetainIfNotDisposed(disposeOfTemporaryRetain);
     if (undisposedPair !== null) {
       onCommit(undisposedPair);
     } else {
       // The cache item we created during render has been disposed. Check if the parent
       // cache is populated.
-      const existingCacheItemCleanupPair =
-        parentCache.getAndPermanentRetainIfPresent();
+      const existingCacheItemCleanupPair = parentCache.getAndPermanentRetainIfPresent();
       if (existingCacheItemCleanupPair !== null) {
         onCommit(existingCacheItemCleanupPair);
       } else {
@@ -97,8 +94,7 @@ export function useCachedPrecommitValue<T>(
 
   // Safety: item is only safe to use (i.e. guaranteed not to have disposed)
   // during this tick.
-  const [cacheItem, item, disposeOfTemporaryRetain] =
-    parentCache.getOrPopulateAndTemporaryRetain();
+  const [cacheItem, item, disposeOfTemporaryRetain] = parentCache.getOrPopulateAndTemporaryRetain();
 
   return { state: item };
 }

package/src/useDisposableState.ts

@@ -1,12 +1,12 @@
-import { useEffect, useRef } from "react";
-import { ParentCache } from "./ParentCache";
-import { ItemCleanupPair } from "@isograph/disposable-types";
-import { useCachedPrecommitValue } from "./useCachedPrecommitValue";
+import { useEffect, useRef } from 'react';
+import { ParentCache } from './ParentCache';
+import { ItemCleanupPair } from '@isograph/disposable-types';
+import { useCachedPrecommitValue } from './useCachedPrecommitValue';
 import {
   UNASSIGNED_STATE,
   UnassignedState,
   useUpdatableDisposableState,
-} from "./useUpdatableDisposableState";
+} from './useUpdatableDisposableState';
 
 type UseUpdatableDisposableStateReturnValue<T> = {
   state: T;
@@ -14,7 +14,7 @@ type UseUpdatableDisposableStateReturnValue<T> = {
 };
 
 export function useDisposableState<T = never>(
-  parentCache: ParentCache<T>
+  parentCache: ParentCache<T>,
 ): UseUpdatableDisposableStateReturnValue<T> {
   const itemCleanupPairRef = useRef<ItemCleanupPair<T> | null>(null);
 
@@ -22,8 +22,7 @@ export function useDisposableState<T = never>(
     itemCleanupPairRef.current = pair;
   });
 
-  const { state: stateFromDisposableStateHook, setState } =
-    useUpdatableDisposableState<T>();
+  const { state: stateFromDisposableStateHook, setState } = useUpdatableDisposableState<T>();
 
   useEffect(
     function cleanupItemCleanupPairRefAfterSetState() {
@@ -33,13 +32,13 @@ export function useDisposableState<T = never>(
           itemCleanupPairRef.current = null;
         } else {
           throw new Error(
-            "itemCleanupPairRef.current is unexpectedly null. " +
-              "This indicates a bug in react-disposable-state."
+            'itemCleanupPairRef.current is unexpectedly null. ' +
+              'This indicates a bug in react-disposable-state.',
           );
         }
       }
     },
-    [stateFromDisposableStateHook]
+    [stateFromDisposableStateHook],
   );
 
   useEffect(function cleanupItemCleanupPairRefIfSetStateNotCalled() {
@@ -65,9 +64,7 @@ export function useDisposableState<T = never>(
   // can still be assigned, during the render before the
   // cleanupItemCleanupPairRefAfterSetState effect is called.
   const state: T | undefined =
-    (stateFromDisposableStateHook != UNASSIGNED_STATE
-      ? stateFromDisposableStateHook
-      : null) ??
+    (stateFromDisposableStateHook != UNASSIGNED_STATE ? stateFromDisposableStateHook : null) ??
     itemCleanupPairRef.current?.[0] ??
     preCommitItem?.state;
 
@@ -82,11 +79,11 @@ function tsTests() {
   let x: any;
   const a = useDisposableState(x);
   // @ts-expect-error
-  a.setState(["asdf", () => {}]);
+  a.setState(['asdf', () => {}]);
   // @ts-expect-error
   a.setState([UNASSIGNED_STATE, () => {}]);
   const b = useDisposableState<string | UnassignedState>(x);
   // @ts-expect-error
   b.setState([UNASSIGNED_STATE, () => {}]);
-  b.setState(["asdf", () => {}]);
+  b.setState(['asdf', () => {}]);
 }

package/src/useHasCommittedRef.ts

@@ -1,4 +1,4 @@
-import { MutableRefObject, useEffect, useRef } from "react";
+import { MutableRefObject, useEffect, useRef } from 'react';
 
 /**
  * Returns true if the component has committed, false otherwise.

package/src/useLazyDisposableState.ts

@@ -1,9 +1,9 @@
-"use strict";
+'use strict';
 
-import { useEffect, useRef } from "react";
-import type { ItemCleanupPair } from "@isograph/disposable-types";
-import { ParentCache } from "./ParentCache";
-import { useCachedPrecommitValue } from "./useCachedPrecommitValue";
+import { useEffect, useRef } from 'react';
+import type { ItemCleanupPair } from '@isograph/disposable-types';
+import { ParentCache } from './ParentCache';
+import { useCachedPrecommitValue } from './useCachedPrecommitValue';
 
 /**
  * useLazyDisposableState<T>
@@ -28,7 +28,7 @@ export function useLazyDisposableState<T>(parentCache: ParentCache<T>): {
     // TODO confirm useEffect is called in order.
     if (cleanupFn == null) {
       throw new Error(
-        "cleanupFn unexpectedly null. This indicates a bug in react-disposable-state."
+        'cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.',
       );
     }
     return cleanupFn;
@@ -43,6 +43,6 @@ export function useLazyDisposableState<T>(parentCache: ParentCache<T>): {
   // is non-null. During the initial commit, we assign itemCleanupPairRef.current,
   // so during subsequent renders, itemCleanupPairRef.current is non-null.
   throw new Error(
-    "returnedItem was unexpectedly null. This indicates a bug in react-disposable-state."
+    'returnedItem was unexpectedly null. This indicates a bug in react-disposable-state.',
   );
 }

package/src/useUpdatableDisposableState.test.tsx

@@ -1,10 +1,7 @@
-import { describe, test, vi, expect } from "vitest";
-import React from "react";
-import { create } from "react-test-renderer";
-import {
-  useUpdatableDisposableState,
-  UNASSIGNED_STATE,
-} from "./useUpdatableDisposableState";
+import { describe, test, vi, expect } from 'vitest';
+import React from 'react';
+import { create } from 'react-test-renderer';
+import { useUpdatableDisposableState, UNASSIGNED_STATE } from './useUpdatableDisposableState';
 
 function Suspender({ promise, isResolvedRef }) {
   if (!isResolvedRef.current) {
@@ -44,29 +41,26 @@ function promiseAndResolver() {
 // The fact that sometimes we need to render in concurrent mode and sometimes
 // not is a bit worrisome.
 async function awaitableCreate(Component, isConcurrent) {
-  const element = create(
-    Component,
-    isConcurrent ? { unstable_isConcurrent: true } : undefined
-  );
+  const element = create(Component, isConcurrent ? { unstable_isConcurrent: true } : undefined);
   await shortPromise();
   return element;
 }
 
-describe("useUpdatableDisposableState", () => {
-  test("it should return a sentinel value initially and a setter", async () => {
+describe('useUpdatableDisposableState', () => {
+  test('it should return a sentinel value initially and a setter', async () => {
     const render = vi.fn();
     function TestComponent() {
       render();
       const value = useUpdatableDisposableState();
       expect(value.state).toBe(UNASSIGNED_STATE);
-      expect(typeof value.setState).toBe("function");
+      expect(typeof value.setState).toBe('function');
       return null;
     }
     await awaitableCreate(<TestComponent />, false);
     expect(render).toHaveBeenCalledTimes(1);
   });
 
-  test("it should allow you to update the value in state", async () => {
+  test('it should allow you to update the value in state', async () => {
     const render = vi.fn();
     let value;
     function TestComponent() {
@@ -85,7 +79,7 @@ describe("useUpdatableDisposableState", () => {
     expect(value.state).toEqual(1);
   });
 
-  test("it should dispose previous values on commit", async () => {
+  test('it should dispose previous values on commit', async () => {
     const render = vi.fn();
     const componentCommits = vi.fn();
     let value;
@@ -120,7 +114,7 @@ describe("useUpdatableDisposableState", () => {
     expect(componentCommits).toHaveBeenCalled();
   });
 
-  test("it should dispose identical previous values on commit", async () => {
+  test('it should dispose identical previous values on commit', async () => {
     const render = vi.fn();
     const componentCommits = vi.fn();
     let value;
@@ -158,7 +152,7 @@ describe("useUpdatableDisposableState", () => {
     expect(componentCommits).toHaveBeenCalled();
   });
 
-  test("it should dispose multiple previous values on commit", async () => {
+  test('it should dispose multiple previous values on commit', async () => {
     const render = vi.fn();
     const componentCommits = vi.fn();
     let value;
@@ -202,7 +196,7 @@ describe("useUpdatableDisposableState", () => {
     expect(componentCommits).toHaveBeenCalled();
   });
 
-  test("it should throw if setState is called during a render before commit", async () => {
+  test('it should throw if setState is called during a render before commit', async () => {
     let didCatch;
     function TestComponent() {
       const value = useUpdatableDisposableState<number>();
@@ -219,7 +213,7 @@ describe("useUpdatableDisposableState", () => {
     expect(didCatch).toBe(true);
   });
 
-  test("it should not throw if setState is called during render after commit", async () => {
+  test('it should not throw if setState is called during render after commit', async () => {
     let value;
     const cleanupFn = vi.fn();
     const sawCorrectValue = vi.fn();
@@ -254,7 +248,7 @@ describe("useUpdatableDisposableState", () => {
     expect(value.state).toBe(1);
   });
 
-  test("it should throw if setState is called after a render before commit", async () => {
+  test('it should throw if setState is called after a render before commit', async () => {
     let value;
     const componentCommits = vi.fn();
     function TestComponent() {
@@ -271,7 +265,7 @@ describe("useUpdatableDisposableState", () => {
         <TestComponent />
         <Suspender promise={promise} isResolvedRef={isResolvedRef} />
       </React.Suspense>,
-      true
+      true,
     );
 
     expect(componentCommits).not.toHaveBeenCalled();
@@ -282,8 +276,8 @@ describe("useUpdatableDisposableState", () => {
   });
 
   test(
-    "it should dispose items that were set during " +
-      "suspense when the component commits due to unsuspense",
+    'it should dispose items that were set during ' +
+      'suspense when the component commits due to unsuspense',
     async () => {
       // Note that "during suspense" implies that there is no commit, so this
       // follows from the descriptions of the previous tests. Nonetheless, we
@@ -320,7 +314,7 @@ describe("useUpdatableDisposableState", () => {
         <React.Suspense fallback="fallback">
           <ParentComponent />
         </React.Suspense>,
-        true
+        true,
       );
 
       expect(render).toHaveBeenCalledTimes(1);
@@ -354,10 +348,10 @@ describe("useUpdatableDisposableState", () => {
       expect(cleanup1).toHaveBeenCalledTimes(1);
       expect(render).toHaveBeenCalledTimes(3);
       expect(componentCommits).toHaveBeenCalledTimes(2);
-    }
+    },
   );
 
-  test("it should properly clean up all items passed to setState during suspense on unmount", async () => {
+  test('it should properly clean up all items passed to setState during suspense on unmount', async () => {
     let value;
     const componentCommits = vi.fn();
     const render = vi.fn();
@@ -391,7 +385,7 @@ describe("useUpdatableDisposableState", () => {
       <React.Suspense fallback="fallback">
         <ParentComponent shouldMountRef={shouldMountRef} />
       </React.Suspense>,
-      true
+      true,
     );
 
     expect(render).toHaveBeenCalledTimes(1);
@@ -430,7 +424,7 @@ describe("useUpdatableDisposableState", () => {
     expect(cleanup2).toHaveBeenCalled();
   });
 
-  test("it should clean up the item currently in state on unmount", async () => {
+  test('it should clean up the item currently in state on unmount', async () => {
     let value;
     const componentCommits = vi.fn();
     const render = vi.fn();
@@ -452,10 +446,7 @@ describe("useUpdatableDisposableState", () => {
 
     const shouldMountRef = { current: true };
 
-    await awaitableCreate(
-      <ParentComponent shouldMountRef={shouldMountRef} />,
-      true
-    );
+    await awaitableCreate(<ParentComponent shouldMountRef={shouldMountRef} />, true);
 
     expect(render).toHaveBeenCalledTimes(1);
     expect(componentCommits).toHaveBeenCalledTimes(1);