@isograph/react-disposable-state 0.0.4 → 0.1.0

package/src/CacheItem.test.ts

@@ -6,19 +6,19 @@ import {
   beforeEach,
   afterEach,
   expect,
-} from "vitest";
+} from 'vitest';
 import {
   CacheItem,
   CacheItemState,
   createTemporarilyRetainedCacheItem,
-} from "./CacheItem";
-import { ItemCleanupPair } from "@isograph/disposable-types";
+} from './CacheItem';
+import { ItemCleanupPair } from '@isograph/disposable-types';
 
 function getState<T>(cacheItem: CacheItem<T>): CacheItemState<T> {
   return (cacheItem as any).__state as CacheItemState<T>;
 }
 
-describe("CacheItem", () => {
+describe('CacheItem', () => {
   beforeEach(() => {
     vi.useFakeTimers();
   });
@@ -26,8 +26,8 @@ describe("CacheItem", () => {
     vi.useRealTimers();
   });
 
-  describe("Item that is temporarily retained once", () => {
-    test("Temporarily retained cache item gets created in the expected state", () => {
+  describe('Item that is temporarily retained once', () => {
+    test('Temporarily retained cache item gets created in the expected state', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
       const factory = vi.fn(() => {
@@ -37,13 +37,13 @@ describe("CacheItem", () => {
       const [cacheItem, _disposeTemporaryRetain] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       expect(factory.mock.calls.length).toEqual(1);
 
       const state = getState(cacheItem);
-      assert(state.kind === "InParentCacheAndNotDisposed");
+      assert(state.kind === 'InParentCacheAndNotDisposed');
       expect(state.value).toEqual(1);
       expect(state.permanentRetainCount).toEqual(0);
       expect(state.temporaryRetainCount).toEqual(1);
@@ -53,7 +53,7 @@ describe("CacheItem", () => {
       expect(removeFromParentCache.mock.calls.length).toEqual(0);
     });
 
-    test("Disposal of temporarily retained cache item", () => {
+    test('Disposal of temporarily retained cache item', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
       const factory = vi.fn(() => {
@@ -63,7 +63,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       expect(factory.mock.calls.length).toEqual(1);
@@ -72,12 +72,12 @@ describe("CacheItem", () => {
 
       const state = getState(cacheItem);
 
-      expect(state.kind).toEqual("NotInParentCacheAndDisposed");
+      expect(state.kind).toEqual('NotInParentCacheAndDisposed');
       expect(removeFromParentCache.mock.calls.length).toEqual(1);
       expect(disposeItem.mock.calls.length).toEqual(1);
     });
 
-    test("Expiration of temporarily retained cache item", () => {
+    test('Expiration of temporarily retained cache item', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -88,7 +88,7 @@ describe("CacheItem", () => {
       const [cacheItem, _disposeTemporaryRetain] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       expect(factory.mock.calls.length).toEqual(1);
@@ -97,12 +97,12 @@ describe("CacheItem", () => {
 
       const state = getState(cacheItem);
 
-      assert(state.kind === "NotInParentCacheAndDisposed");
+      assert(state.kind === 'NotInParentCacheAndDisposed');
       expect(removeFromParentCache.mock.calls.length).toEqual(1);
       expect(disposeItem.mock.calls.length).toEqual(1);
     });
 
-    test("Disposal of expired temporarily retained cache item", () => {
+    test('Disposal of expired temporarily retained cache item', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -113,7 +113,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       expect(factory.mock.calls.length).toEqual(1);
@@ -122,7 +122,7 @@ describe("CacheItem", () => {
 
       const state = getState(cacheItem);
 
-      assert(state.kind === "NotInParentCacheAndDisposed");
+      assert(state.kind === 'NotInParentCacheAndDisposed');
       expect(removeFromParentCache.mock.calls.length).toEqual(1);
       expect(disposeItem.mock.calls.length).toEqual(1);
 
@@ -131,7 +131,7 @@ describe("CacheItem", () => {
       }).not.toThrow();
     });
 
-    test("Repeated disposal of temporarily retained cache item", () => {
+    test('Repeated disposal of temporarily retained cache item', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -142,7 +142,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       expect(factory.mock.calls.length).toEqual(1);
@@ -150,7 +150,7 @@ describe("CacheItem", () => {
       disposeTemporaryRetain();
       const state = getState(cacheItem);
 
-      assert(state.kind === "NotInParentCacheAndDisposed");
+      assert(state.kind === 'NotInParentCacheAndDisposed');
       expect(removeFromParentCache.mock.calls.length).toEqual(1);
       expect(disposeItem.mock.calls.length).toEqual(1);
 
@@ -160,8 +160,8 @@ describe("CacheItem", () => {
     });
   });
 
-  describe("Item that is temporarily retained once and then permanently retained", () => {
-    test("Permanent retain removes the item from the parent", () => {
+  describe('Item that is temporarily retained once and then permanently retained', () => {
+    test('Permanent retain removes the item from the parent', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -172,7 +172,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       const mockedDisposeTemporaryRetain = vi.fn(disposeTemporaryRetain);
@@ -187,7 +187,7 @@ describe("CacheItem", () => {
 
       const state = getState(cacheItem);
 
-      assert(state.kind === "NotInParentCacheAndNotDisposed");
+      assert(state.kind === 'NotInParentCacheAndNotDisposed');
       expect(state.disposeValue).toEqual(disposeItem);
       expect(state.permanentRetainCount).toEqual(1);
       expect(state.value).toEqual(1);
@@ -195,7 +195,7 @@ describe("CacheItem", () => {
       expect(removeFromParentCache.mock.calls.length).toEqual(1);
     });
 
-    test("Disposing the temporary retain after permanent retain throws", () => {
+    test('Disposing the temporary retain after permanent retain throws', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -206,7 +206,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       expect(factory.mock.calls.length).toEqual(1);
@@ -219,7 +219,7 @@ describe("CacheItem", () => {
       }).toThrow();
     });
 
-    test("Item is disposed when the permanently retain is disposed", () => {
+    test('Item is disposed when the permanently retain is disposed', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -230,7 +230,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       const mockedDisposeTemporaryRetain = vi.fn(disposeTemporaryRetain);
@@ -243,12 +243,12 @@ describe("CacheItem", () => {
       disposePermanentRetain();
 
       const state = getState(cacheItem);
-      assert(state.kind === "NotInParentCacheAndDisposed");
+      assert(state.kind === 'NotInParentCacheAndDisposed');
       expect(removeFromParentCache.mock.calls.length).toEqual(1);
       expect(disposeItem.mock.calls.length).toEqual(1);
     });
 
-    test("Repeated disposal of permanently retained cache item throws", () => {
+    test('Repeated disposal of permanently retained cache item throws', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -259,7 +259,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       const mockedDisposeTemporaryRetain = vi.fn(disposeTemporaryRetain);
@@ -275,7 +275,7 @@ describe("CacheItem", () => {
       }).toThrow();
     });
 
-    test("Permanent retain of cache item whose temporary retain has expired", () => {
+    test('Permanent retain of cache item whose temporary retain has expired', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -286,7 +286,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       expect(factory.mock.calls.length).toEqual(1);
@@ -295,10 +295,10 @@ describe("CacheItem", () => {
 
       const state = getState(cacheItem);
 
-      assert(state.kind === "NotInParentCacheAndDisposed");
+      assert(state.kind === 'NotInParentCacheAndDisposed');
 
       assert(
-        cacheItem.permanentRetainIfNotDisposed(disposeTemporaryRetain) === null
+        cacheItem.permanentRetainIfNotDisposed(disposeTemporaryRetain) === null,
       );
 
       expect(() => {
@@ -306,7 +306,7 @@ describe("CacheItem", () => {
       }).toThrow();
     });
 
-    test("It is invalid to temporarily retain after the permanent retain", () => {
+    test('It is invalid to temporarily retain after the permanent retain', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -317,7 +317,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       const [_value, disposeOfPermanentRetain1] =
@@ -329,8 +329,8 @@ describe("CacheItem", () => {
     });
   });
 
-  describe("Item that temporarily retained twice", () => {
-    test("Cache item is not disposed after first temporary retain expires", () => {
+  describe('Item that temporarily retained twice', () => {
+    test('Cache item is not disposed after first temporary retain expires', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -341,7 +341,7 @@ describe("CacheItem", () => {
       const [cacheItem, _disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -351,7 +351,7 @@ describe("CacheItem", () => {
       vi.advanceTimersToNextTimer();
 
       const state = getState(cacheItem);
-      assert(state.kind === "InParentCacheAndNotDisposed");
+      assert(state.kind === 'InParentCacheAndNotDisposed');
       expect(state.value).toEqual(1);
       expect(state.permanentRetainCount).toEqual(0);
       expect(state.temporaryRetainCount).toEqual(1);
@@ -361,7 +361,7 @@ describe("CacheItem", () => {
       expect(removeFromParentCache.mock.calls.length).toEqual(0);
     });
 
-    test("Cache item is not disposed after first temporary retain is disposed", () => {
+    test('Cache item is not disposed after first temporary retain is disposed', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -372,7 +372,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -381,7 +381,7 @@ describe("CacheItem", () => {
       disposeTemporaryRetain1();
 
       const state = getState(cacheItem);
-      assert(state.kind === "InParentCacheAndNotDisposed");
+      assert(state.kind === 'InParentCacheAndNotDisposed');
       expect(state.value).toEqual(1);
       expect(state.permanentRetainCount).toEqual(0);
       expect(state.temporaryRetainCount).toEqual(1);
@@ -391,7 +391,7 @@ describe("CacheItem", () => {
       expect(removeFromParentCache.mock.calls.length).toEqual(0);
     });
 
-    test("Disposing the first temporary retain after it expires is a no-op", () => {
+    test('Disposing the first temporary retain after it expires is a no-op', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -402,7 +402,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -411,11 +411,11 @@ describe("CacheItem", () => {
       disposeTemporaryRetain1();
 
       const state = getState(cacheItem);
-      assert(state.kind === "InParentCacheAndNotDisposed");
+      assert(state.kind === 'InParentCacheAndNotDisposed');
       expect(state.temporaryRetainCount).toEqual(1);
     });
 
-    test("Item is not disposed if only the second temporary retain is disposed", () => {
+    test('Item is not disposed if only the second temporary retain is disposed', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -426,7 +426,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -434,11 +434,11 @@ describe("CacheItem", () => {
       disposeTemporaryRetain2();
 
       const state = getState(cacheItem);
-      assert(state.kind === "InParentCacheAndNotDisposed");
+      assert(state.kind === 'InParentCacheAndNotDisposed');
       expect(state.temporaryRetainCount).toEqual(1);
     });
 
-    test("Item is disposed if both temporary retains are disposed", () => {
+    test('Item is disposed if both temporary retains are disposed', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -449,22 +449,22 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       const disposeTemporaryRetain2 = cacheItem.temporaryRetain();
       const state1 = getState(cacheItem);
-      assert(state1.kind === "InParentCacheAndNotDisposed");
+      assert(state1.kind === 'InParentCacheAndNotDisposed');
       expect(state1.temporaryRetainCount).toEqual(2);
       disposeTemporaryRetain1();
       expect(state1.temporaryRetainCount).toEqual(1);
       disposeTemporaryRetain2();
 
       const state2 = getState(cacheItem);
-      assert(state2.kind === "NotInParentCacheAndDisposed");
+      assert(state2.kind === 'NotInParentCacheAndDisposed');
     });
 
-    test("Item is disposed if both temporary retains are disposed in reverse order", () => {
+    test('Item is disposed if both temporary retains are disposed in reverse order', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -475,22 +475,22 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       const disposeTemporaryRetain2 = cacheItem.temporaryRetain();
       const state1 = getState(cacheItem);
-      assert(state1.kind === "InParentCacheAndNotDisposed");
+      assert(state1.kind === 'InParentCacheAndNotDisposed');
       expect(state1.temporaryRetainCount).toEqual(2);
       disposeTemporaryRetain2();
       expect(state1.temporaryRetainCount).toEqual(1);
       disposeTemporaryRetain1();
 
       const state2 = getState(cacheItem);
-      assert(state2.kind === "NotInParentCacheAndDisposed");
+      assert(state2.kind === 'NotInParentCacheAndDisposed');
     });
 
-    test("Item is disposed if both temporary retains expire", () => {
+    test('Item is disposed if both temporary retains expire', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -501,14 +501,14 @@ describe("CacheItem", () => {
       const [cacheItem, _disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
       const _disposeTemporaryRetain2 = cacheItem.temporaryRetain();
 
       const state1 = getState(cacheItem);
-      assert(state1.kind === "InParentCacheAndNotDisposed");
+      assert(state1.kind === 'InParentCacheAndNotDisposed');
       expect(state1.temporaryRetainCount).toEqual(2);
 
       vi.advanceTimersToNextTimer();
@@ -516,14 +516,14 @@ describe("CacheItem", () => {
 
       vi.advanceTimersToNextTimer();
       const state = getState(cacheItem);
-      assert(state.kind === "NotInParentCacheAndDisposed");
+      assert(state.kind === 'NotInParentCacheAndDisposed');
       expect(disposeItem.mock.calls.length).toEqual(1);
       expect(removeFromParentCache.mock.calls.length).toEqual(1);
     });
   });
 
-  describe("Item that is temporarily retained twice and then permanently retained", () => {
-    test("Item is not removed from the parent cache when the permanent retain is created", () => {
+  describe('Item that is temporarily retained twice and then permanently retained', () => {
+    test('Item is not removed from the parent cache when the permanent retain is created', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -534,7 +534,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -545,13 +545,13 @@ describe("CacheItem", () => {
 
       const state = getState(cacheItem);
 
-      assert(state.kind === "InParentCacheAndNotDisposed");
+      assert(state.kind === 'InParentCacheAndNotDisposed');
       expect(state.value).toEqual(1);
       expect(state.permanentRetainCount).toEqual(1);
       expect(state.temporaryRetainCount).toEqual(1);
     });
 
-    test("Item is removed from the parent cache when the second temporary retain is disposed", () => {
+    test('Item is removed from the parent cache when the second temporary retain is disposed', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -562,7 +562,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -572,18 +572,18 @@ describe("CacheItem", () => {
         cacheItem.permanentRetainIfNotDisposed(disposeTemporaryRetain1)!;
 
       const state1 = getState(cacheItem);
-      assert(state1.kind === "InParentCacheAndNotDisposed");
+      assert(state1.kind === 'InParentCacheAndNotDisposed');
       expect(state1.permanentRetainCount).toEqual(1);
       expect(state1.temporaryRetainCount).toEqual(1);
 
       disposeTemporaryRetain2();
 
       const state2 = getState(cacheItem);
-      assert(state2.kind === "NotInParentCacheAndNotDisposed");
+      assert(state2.kind === 'NotInParentCacheAndNotDisposed');
       expect(state2.permanentRetainCount).toEqual(1);
     });
 
-    test("Item is removed from the parent cache when the second temporary retain expires", () => {
+    test('Item is removed from the parent cache when the second temporary retain expires', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -594,7 +594,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -604,18 +604,18 @@ describe("CacheItem", () => {
         cacheItem.permanentRetainIfNotDisposed(disposeTemporaryRetain1)!;
 
       const state1 = getState(cacheItem);
-      assert(state1.kind === "InParentCacheAndNotDisposed");
+      assert(state1.kind === 'InParentCacheAndNotDisposed');
       expect(state1.permanentRetainCount).toEqual(1);
       expect(state1.temporaryRetainCount).toEqual(1);
 
       vi.advanceTimersToNextTimer();
 
       const state2 = getState(cacheItem);
-      assert(state2.kind === "NotInParentCacheAndNotDisposed");
+      assert(state2.kind === 'NotInParentCacheAndNotDisposed');
       expect(state2.permanentRetainCount).toEqual(1);
     });
 
-    test("Item is not removed from the parent cache when the permanent retain is disposed", () => {
+    test('Item is not removed from the parent cache when the permanent retain is disposed', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -626,7 +626,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -638,12 +638,12 @@ describe("CacheItem", () => {
       disposeOfPermanentRetain();
 
       const state = getState(cacheItem);
-      assert(state.kind === "InParentCacheAndNotDisposed");
+      assert(state.kind === 'InParentCacheAndNotDisposed');
       expect(state.permanentRetainCount).toEqual(0);
       expect(state.temporaryRetainCount).toEqual(1);
     });
 
-    test("Item is disposed the permanent retain is disposed and the second temporary retain expires", () => {
+    test('Item is disposed the permanent retain is disposed and the second temporary retain expires', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -654,7 +654,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -667,10 +667,10 @@ describe("CacheItem", () => {
       vi.advanceTimersToNextTimer();
 
       const state = getState(cacheItem);
-      assert(state.kind === "NotInParentCacheAndDisposed");
+      assert(state.kind === 'NotInParentCacheAndDisposed');
     });
 
-    test("Item is disposed when the permanent retain is disposed and the second temporary retain is disposed", () => {
+    test('Item is disposed when the permanent retain is disposed and the second temporary retain is disposed', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -681,7 +681,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -694,10 +694,10 @@ describe("CacheItem", () => {
       disposeTemporaryRetain2();
 
       const state = getState(cacheItem);
-      assert(state.kind === "NotInParentCacheAndDisposed");
+      assert(state.kind === 'NotInParentCacheAndDisposed');
     });
 
-    test("Item is disposed when the second temporary is disposed and the permanent retain is disposed", () => {
+    test('Item is disposed when the second temporary is disposed and the permanent retain is disposed', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -708,7 +708,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -721,10 +721,10 @@ describe("CacheItem", () => {
       disposeOfPermanentRetain();
 
       const state = getState(cacheItem);
-      assert(state.kind === "NotInParentCacheAndDisposed");
+      assert(state.kind === 'NotInParentCacheAndDisposed');
     });
 
-    test("Item is disposed when the second temporary expires and the permanent retain is disposed", () => {
+    test('Item is disposed when the second temporary expires and the permanent retain is disposed', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -735,7 +735,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -748,12 +748,12 @@ describe("CacheItem", () => {
       disposeOfPermanentRetain();
 
       const state = getState(cacheItem);
-      assert(state.kind === "NotInParentCacheAndDisposed");
+      assert(state.kind === 'NotInParentCacheAndDisposed');
     });
   });
 
-  describe("Multiple permanent retains", () => {
-    test("Item is only disposed when second permanent retain is disposed", () => {
+  describe('Multiple permanent retains', () => {
+    test('Item is only disposed when second permanent retain is disposed', () => {
       const removeFromParentCache = vi.fn();
       const disposeItem = vi.fn();
 
@@ -764,7 +764,7 @@ describe("CacheItem", () => {
       const [cacheItem, disposeTemporaryRetain1] =
         createTemporarilyRetainedCacheItem<number>(
           factory,
-          removeFromParentCache
+          removeFromParentCache,
         );
 
       vi.advanceTimersByTime(1000);
@@ -777,12 +777,12 @@ describe("CacheItem", () => {
 
       disposeOfPermanentRetain1();
       const state = getState(cacheItem);
-      assert(state.kind === "NotInParentCacheAndNotDisposed");
+      assert(state.kind === 'NotInParentCacheAndNotDisposed');
       expect(state.permanentRetainCount).toEqual(1);
 
       disposeOfPermanentRetain2();
       const state2 = getState(cacheItem);
-      assert(state2.kind === "NotInParentCacheAndDisposed");
+      assert(state2.kind === 'NotInParentCacheAndDisposed');
     });
   });
 });