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

package/src/CacheItem.test.ts

@@ -1,24 +1,12 @@
-import {
-  describe,
-  assert,
-  test,
-  vi,
-  beforeEach,
-  afterEach,
-  expect,
-} from "vitest";
-import {
-  CacheItem,
-  CacheItemState,
-  createTemporarilyRetainedCacheItem,
-} from "./CacheItem";
-import { ItemCleanupPair } from "@isograph/disposable-types";
+import { describe, assert, test, vi, beforeEach, afterEach, expect } from 'vitest';
+import { CacheItem, CacheItemState, createTemporarilyRetainedCacheItem } 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,24 +14,23 @@ 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(() => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, _disposeTemporaryRetain] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, _disposeTemporaryRetain] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        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,18 +40,17 @@ 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(() => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       expect(factory.mock.calls.length).toEqual(1);
 
@@ -72,12 +58,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();
 
@@ -85,11 +71,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, _disposeTemporaryRetain] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, _disposeTemporaryRetain] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       expect(factory.mock.calls.length).toEqual(1);
 
@@ -97,12 +82,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();
 
@@ -110,11 +95,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       expect(factory.mock.calls.length).toEqual(1);
 
@@ -122,7 +106,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 +115,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();
 
@@ -139,18 +123,17 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       expect(factory.mock.calls.length).toEqual(1);
 
       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 +143,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();
 
@@ -169,25 +152,25 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       const mockedDisposeTemporaryRetain = vi.fn(disposeTemporaryRetain);
 
       expect(factory.mock.calls.length).toEqual(1);
 
-      const [item, _disposePermanentRetain] =
-        cacheItem.permanentRetainIfNotDisposed(mockedDisposeTemporaryRetain)!;
+      const [item, _disposePermanentRetain] = cacheItem.permanentRetainIfNotDisposed(
+        mockedDisposeTemporaryRetain,
+      )!;
 
       expect(item).toEqual(1);
       expect(mockedDisposeTemporaryRetain.mock.calls.length).toEqual(1);
 
       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 +178,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();
 
@@ -203,11 +186,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       expect(factory.mock.calls.length).toEqual(1);
 
@@ -219,7 +201,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();
 
@@ -227,28 +209,28 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       const mockedDisposeTemporaryRetain = vi.fn(disposeTemporaryRetain);
 
       expect(factory.mock.calls.length).toEqual(1);
 
-      const [item, disposePermanentRetain] =
-        cacheItem.permanentRetainIfNotDisposed(mockedDisposeTemporaryRetain)!;
+      const [item, disposePermanentRetain] = cacheItem.permanentRetainIfNotDisposed(
+        mockedDisposeTemporaryRetain,
+      )!;
 
       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();
 
@@ -256,18 +238,18 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       const mockedDisposeTemporaryRetain = vi.fn(disposeTemporaryRetain);
 
       expect(factory.mock.calls.length).toEqual(1);
 
-      const [item, disposePermanentRetain] =
-        cacheItem.permanentRetainIfNotDisposed(mockedDisposeTemporaryRetain)!;
+      const [item, disposePermanentRetain] = cacheItem.permanentRetainIfNotDisposed(
+        mockedDisposeTemporaryRetain,
+      )!;
 
       disposePermanentRetain();
       expect(() => {
@@ -275,7 +257,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();
 
@@ -283,11 +265,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       expect(factory.mock.calls.length).toEqual(1);
 
@@ -295,18 +276,16 @@ describe("CacheItem", () => {
 
       const state = getState(cacheItem);
 
-      assert(state.kind === "NotInParentCacheAndDisposed");
+      assert(state.kind === 'NotInParentCacheAndDisposed');
 
-      assert(
-        cacheItem.permanentRetainIfNotDisposed(disposeTemporaryRetain) === null
-      );
+      assert(cacheItem.permanentRetainIfNotDisposed(disposeTemporaryRetain) === null);
 
       expect(() => {
         cacheItem.permanentRetain();
       }).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();
 
@@ -314,11 +293,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       const [_value, disposeOfPermanentRetain1] =
         cacheItem.permanentRetainIfNotDisposed(disposeTemporaryRetain1)!;
@@ -329,8 +307,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();
 
@@ -338,11 +316,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, _disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, _disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
 
@@ -351,7 +328,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 +338,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();
 
@@ -369,11 +346,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
       const _disposeTemporaryRetain2 = cacheItem.temporaryRetain();
@@ -381,7 +357,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 +367,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();
 
@@ -399,11 +375,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
       const _disposeTemporaryRetain2 = cacheItem.temporaryRetain();
@@ -411,11 +386,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();
 
@@ -423,22 +398,21 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
       const disposeTemporaryRetain2 = cacheItem.temporaryRetain();
       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();
 
@@ -446,25 +420,24 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        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();
 
@@ -472,25 +445,24 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        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();
 
@@ -498,17 +470,16 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, _disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, _disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        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 +487,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();
 
@@ -531,11 +502,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
       const _disposeTemporaryRetain2 = cacheItem.temporaryRetain();
@@ -545,13 +515,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();
 
@@ -559,11 +529,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
       const disposeTemporaryRetain2 = cacheItem.temporaryRetain();
@@ -572,18 +541,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();
 
@@ -591,11 +560,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
       const _disposeTemporaryRetain2 = cacheItem.temporaryRetain();
@@ -604,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);
 
       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();
 
@@ -623,11 +591,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
       const _disposeTemporaryRetain2 = cacheItem.temporaryRetain();
@@ -638,12 +605,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();
 
@@ -651,11 +618,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
       const _disposeTemporaryRetain2 = cacheItem.temporaryRetain();
@@ -667,10 +633,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();
 
@@ -678,11 +644,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
       const disposeTemporaryRetain2 = cacheItem.temporaryRetain();
@@ -694,10 +659,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();
 
@@ -705,11 +670,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
       const disposeTemporaryRetain2 = cacheItem.temporaryRetain();
@@ -721,10 +685,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();
 
@@ -732,11 +696,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
       const _disposeTemporaryRetain2 = cacheItem.temporaryRetain();
@@ -748,12 +711,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();
 
@@ -761,11 +724,10 @@ describe("CacheItem", () => {
         const ret: ItemCleanupPair<number> = [1, disposeItem];
         return ret;
       });
-      const [cacheItem, disposeTemporaryRetain1] =
-        createTemporarilyRetainedCacheItem<number>(
-          factory,
-          removeFromParentCache
-        );
+      const [cacheItem, disposeTemporaryRetain1] = createTemporarilyRetainedCacheItem<number>(
+        factory,
+        removeFromParentCache,
+      );
 
       vi.advanceTimersByTime(1000);
       const disposeTemporaryRetain2 = cacheItem.temporaryRetain();
@@ -777,12 +739,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');
     });
   });
 });