@isograph/react-disposable-state 0.0.4 → 0.1.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
@@ -66,7 +66,7 @@ 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
+      disposeOfTemporaryRetain,
     );
     if (undisposedPair !== null) {
       onCommit(undisposedPair);

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);
 
@@ -33,13 +33,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() {
@@ -81,12 +81,14 @@ export function useDisposableState<T = never>(
 function tsTests() {
   let x: any;
   const a = useDisposableState(x);
+  // This should be a compiler error, because the generic is inferred to be of
+  // type never. TODO determine why this doesn't break the build!
   // @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.',
   );
 }