@isograph/react-disposable-state 0.5.0 → 0.5.1

package/src/CacheItem.test.ts

@@ -1,4 +1,4 @@
-import { ItemCleanupPair } from '@isograph/disposable-types';
+import type { ItemCleanupPair } from '@isograph/disposable-types';
 import {
   afterEach,
   assert,
@@ -8,11 +8,8 @@ import {
   test,
   vi,
 } from 'vitest';
-import {
-  CacheItem,
-  CacheItemState,
-  createTemporarilyRetainedCacheItem,
-} from './CacheItem';
+import type { CacheItem, CacheItemState } from './CacheItem';
+import { createTemporarilyRetainedCacheItem } from './CacheItem';
 
 function getState<T>(cacheItem: CacheItem<T>): CacheItemState<T> {
   return (cacheItem as any).__state as CacheItemState<T>;
@@ -298,7 +295,7 @@ describe('CacheItem', () => {
       assert(state.kind === 'NotInParentCacheAndDisposed');
 
       assert(
-        cacheItem.permanentRetainIfNotDisposed(disposeTemporaryRetain) === null,
+        cacheItem.permanentRetainIfNotDisposed(disposeTemporaryRetain) == null,
       );
 
       expect(() => {

package/src/CacheItem.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   CleanupFn,
   Factory,
   ItemCleanupPair,
@@ -102,7 +102,7 @@ export class CacheItem<T> {
       case 'NotInParentCacheAndNotDisposed': {
         return this.__state.value;
       }
-      default: {
+      case 'NotInParentCacheAndDisposed': {
         throw new Error(
           'Attempted to access disposed value from CacheItem. ' +
             'This indicates a bug in react-disposable-state.',
@@ -142,7 +142,7 @@ export class CacheItem<T> {
                 );
                 return;
               }
-              default: {
+              case 'NotInParentCacheAndDisposed': {
                 throw new Error(
                   'CacheItem was in a disposed state, but there existed a permanent retain. ' +
                     'This indicates a bug in react-disposable-state.',
@@ -174,7 +174,8 @@ export class CacheItem<T> {
                 );
                 return;
               }
-              default: {
+              case 'InParentCacheAndNotDisposed':
+              case 'NotInParentCacheAndDisposed': {
                 throw new Error(
                   'CacheItem was in an unexpected state. ' +
                     'This indicates a bug in react-disposable-state.',
@@ -184,7 +185,7 @@ export class CacheItem<T> {
           },
         ];
       }
-      default: {
+      case 'NotInParentCacheAndDisposed': {
         // The CacheItem is disposed, so disposeOfTemporaryRetain is a no-op
         return null;
       }
@@ -215,7 +216,8 @@ export class CacheItem<T> {
                 clearTimeout(timeoutId);
                 return;
               }
-              default: {
+              case 'NotInParentCacheAndDisposed':
+              case 'NotInParentCacheAndNotDisposed': {
                 throw new Error(
                   'A temporary retain was cleared, for which the CacheItem is in an invalid state. ' +
                     'This indicates a bug in react-disposable-state.',
@@ -233,7 +235,8 @@ export class CacheItem<T> {
               this.__maybeExitInParentCacheAndNotDisposedState(this.__state);
               return;
             }
-            default: {
+            case 'NotInParentCacheAndDisposed':
+            case 'NotInParentCacheAndNotDisposed': {
               throw new Error(
                 'A temporary retain was cleared, for which the CacheItem is in an invalid state. ' +
                   'This indicates a bug in react-disposable-state.',
@@ -248,7 +251,8 @@ export class CacheItem<T> {
         );
         return clearTemporaryRetainByCallack;
       }
-      default: {
+      case 'NotInParentCacheAndDisposed':
+      case 'NotInParentCacheAndNotDisposed': {
         throw new Error(
           'temporaryRetain was called, for which the CacheItem is in an invalid state. ' +
             'This indicates a bug in react-disposable-state.',
@@ -281,7 +285,7 @@ export class CacheItem<T> {
               this.__maybeExitNotInParentCacheAndNotDisposedState(this.__state);
               return;
             }
-            default: {
+            case 'NotInParentCacheAndDisposed': {
               throw new Error(
                 'CacheItem was in a disposed state, but there existed a permanent retain. ' +
                   'This indicates a bug in react-disposable-state.',
@@ -307,7 +311,8 @@ export class CacheItem<T> {
               this.__maybeExitNotInParentCacheAndNotDisposedState(this.__state);
               return;
             }
-            default: {
+            case 'InParentCacheAndNotDisposed':
+            case 'NotInParentCacheAndDisposed': {
               throw new Error(
                 'CacheItem was in an unexpected state. ' +
                   'This indicates a bug in react-disposable-state.',
@@ -316,7 +321,7 @@ export class CacheItem<T> {
           }
         };
       }
-      default: {
+      case 'NotInParentCacheAndDisposed': {
         throw new Error(
           'permanentRetain was called, but the CacheItem is in an invalid state. ' +
             'This indicates a bug in react-disposable-state.',

package/src/ParentCache.test.ts

@@ -1,6 +1,6 @@
-import { ItemCleanupPair } from '@isograph/disposable-types';
+import type { ItemCleanupPair } from '@isograph/disposable-types';
 import { assert, describe, expect, test, vi } from 'vitest';
-import { CacheItem } from './CacheItem';
+import type { CacheItem } from './CacheItem';
 import { ParentCache } from './ParentCache';
 
 function getValue<T>(cache: ParentCache<T>): CacheItem<T> | null {
@@ -26,7 +26,7 @@ describe('ParentCache', () => {
       assert(getValue(parentCache) != null, 'Parent cache should not be empty');
 
       parentCache.empty();
-      assert(getValue(parentCache) === null);
+      assert(getValue(parentCache) == null);
 
       parentCache.getOrPopulateAndTemporaryRetain();
       expect(factory.mock.calls.length).toBe(2);
@@ -50,7 +50,7 @@ describe('ParentCache', () => {
       parentCache.getOrPopulateAndTemporaryRetain();
     clearTemporaryRetain();
 
-    assert(getValue(parentCache) === null);
+    assert(getValue(parentCache) == null);
   });
 
   test('Clearing one of two temporary retains does not remove the item from the parent cache', () => {
@@ -69,6 +69,6 @@ describe('ParentCache', () => {
     assert(getValue(parentCache) != null);
 
     clearTemporaryRetain2();
-    assert(getValue(parentCache) === null);
+    assert(getValue(parentCache) == null);
   });
 });

package/src/ParentCache.ts

@@ -1,9 +1,10 @@
-import {
+import type {
   CleanupFn,
   Factory,
   ItemCleanupPair,
 } from '@isograph/disposable-types';
-import { CacheItem, createTemporarilyRetainedCacheItem } from './CacheItem';
+import type { CacheItem } from './CacheItem';
+import { createTemporarilyRetainedCacheItem } from './CacheItem';
 
 // TODO convert cache impl to a getter and setter and free functions
 // TODO accept options that get passed to CacheItem
@@ -51,7 +52,7 @@ export class ParentCache<T> {
   }
 
   getOrPopulateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn] {
-    return this.__cacheItem === null
+    return this.__cacheItem == null
       ? this.__populateAndTemporaryRetain()
       : temporaryRetain(this.__cacheItem);
   }
@@ -93,7 +94,7 @@ export class ParentCache<T> {
   }
 
   isEmpty(): boolean {
-    return this.__cacheItem === null;
+    return this.__cacheItem == null;
   }
 }
 

package/src/useCachedResponsivePrecommitValue.test.tsx

@@ -1,8 +1,8 @@
-import { ItemCleanupPair } from '@isograph/disposable-types';
-import React from 'react';
+import type { ItemCleanupPair } from '@isograph/disposable-types';
+import React, { type MutableRefObject } from 'react';
 import { create } from 'react-test-renderer';
 import { assert, describe, expect, test, vi } from 'vitest';
-import { CacheItem, CacheItemState } from './CacheItem';
+import type { CacheItem, CacheItemState } from './CacheItem';
 import { ParentCache } from './ParentCache';
 import { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';
 
@@ -14,7 +14,13 @@ function getState<T>(cacheItem: CacheItem<T>): CacheItemState<T> {
   return (cacheItem as any).__state;
 }
 
-function Suspender({ promise, isResolvedRef }) {
+function Suspender({
+  promise,
+  isResolvedRef,
+}: {
+  promise: Promise<unknown>;
+  isResolvedRef: MutableRefObject<boolean>;
+}) {
   if (!isResolvedRef.current) {
     throw promise;
   }
@@ -22,23 +28,18 @@ function Suspender({ promise, isResolvedRef }) {
 }
 
 function shortPromise() {
-  let resolve;
-  const promise = new Promise((_resolve) => {
-    resolve = _resolve;
-  });
+  const { promise, resolve } = Promise.withResolvers<void>();
 
   setTimeout(resolve, 1);
   return promise;
 }
 
 function promiseAndResolver() {
-  let resolve;
   const isResolvedRef = {
     current: false,
   };
-  const promise = new Promise((r) => {
-    resolve = r;
-  });
+  const { promise, resolve } = Promise.withResolvers<void>();
+
   return {
     promise,
     resolve: () => {
@@ -51,7 +52,7 @@ 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) {
+async function awaitableCreate(Component, isConcurrent: boolean) {
   const element = create(
     Component,
     isConcurrent ? { unstable_isConcurrent: true } : undefined,
@@ -157,7 +158,7 @@ describe('useCachedResponsivePrecommitValue', () => {
       setState = _setState;
       const value = useCachedResponsivePrecommitValue(cache, hookOnCommit);
 
-      if (initialRender && value !== null) {
+      if (initialRender && value != null) {
         initialRender = false;
         expect(value).toEqual({ state: 1 });
       } else {

package/src/useCachedResponsivePrecommitValue.ts

@@ -1,8 +1,8 @@
 'use strict';
 
-import { ItemCleanupPair } from '@isograph/disposable-types';
+import type { ItemCleanupPair } from '@isograph/disposable-types';
 import { useEffect, useRef, useState } from 'react';
-import { ParentCache } from './ParentCache';
+import type { ParentCache } from './ParentCache';
 
 /**
  * useCachedResponsivePrecommitValue<T>
@@ -70,14 +70,14 @@ export function useCachedResponsivePrecommitValue<T>(
     const undisposedPair = cacheItem.permanentRetainIfNotDisposed(
       disposeOfTemporaryRetain,
     );
-    if (undisposedPair !== null) {
+    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();
-      if (existingCacheItemCleanupPair !== null) {
+      if (existingCacheItemCleanupPair != null) {
         onCommit(existingCacheItemCleanupPair);
       } else {
         // We did not find an item in the parent cache, create a new one.

package/src/useDisposableState.ts

@@ -1,10 +1,10 @@
-import { ItemCleanupPair } from '@isograph/disposable-types';
+import type { ItemCleanupPair } from '@isograph/disposable-types';
 import { useEffect, useRef } from 'react';
-import { ParentCache } from './ParentCache';
+import type { ParentCache } from './ParentCache';
 import { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';
 import {
   UNASSIGNED_STATE,
-  UnassignedState,
+  type UnassignedState,
   useUpdatableDisposableState,
 } from './useUpdatableDisposableState';
 
@@ -32,7 +32,7 @@ export function useDisposableState<T = never>(
   useEffect(
     function cleanupItemCleanupPairRefAfterSetState() {
       if (stateFromDisposableStateHook !== UNASSIGNED_STATE) {
-        if (itemCleanupPairRef.current !== null) {
+        if (itemCleanupPairRef.current != null) {
           itemCleanupPairRef.current[1]();
           itemCleanupPairRef.current = null;
         } else {
@@ -48,12 +48,25 @@ export function useDisposableState<T = never>(
 
   useEffect(function cleanupItemCleanupPairRefIfSetStateNotCalled() {
     return () => {
-      if (itemCleanupPairRef.current !== null) {
+      if (itemCleanupPairRef.current != null) {
         itemCleanupPairRef.current[1]();
         itemCleanupPairRef.current = null;
       }
     };
   }, []);
+  const state: T | undefined =
+    (stateFromDisposableStateHook !== UNASSIGNED_STATE
+      ? stateFromDisposableStateHook
+      : null) ??
+    preCommitItem?.state ??
+    itemCleanupPairRef.current?.[0];
+
+  if (state != null) {
+    return {
+      state: state,
+      setState,
+    };
+  }
 
   // Safety: we can be in one of three states. Pre-commit, in which case
   // preCommitItem is assigned, post-commit but before setState has been
@@ -68,17 +81,9 @@ export function useDisposableState<T = never>(
   // Note that in the post-commit post-setState state, itemCleanupPairRef
   // can still be assigned, during the render before the
   // cleanupItemCleanupPairRefAfterSetState effect is called.
-  const state: T | undefined =
-    (stateFromDisposableStateHook != UNASSIGNED_STATE
-      ? stateFromDisposableStateHook
-      : null) ??
-    preCommitItem?.state ??
-    itemCleanupPairRef.current?.[0];
-
-  return {
-    state: state!,
-    setState,
-  };
+  throw new Error(
+    'state was unexpectedly null. This indicates a bug in react-disposable-state.',
+  );
 }
 
 // @ts-ignore

package/src/useHasCommittedRef.ts

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

package/src/useLazyDisposableState.test.tsx

@@ -1,4 +1,4 @@
-import { ItemCleanupPair } from '@isograph/disposable-types';
+import type { ItemCleanupPair } from '@isograph/disposable-types';
 import React, { useEffect, useState } from 'react';
 import { create } from 'react-test-renderer';
 import { describe, expect, test, vi } from 'vitest';
@@ -47,7 +47,7 @@ describe('useLazyDisposableState', async () => {
       }, []);
 
       useEffect(() => {
-        if (state == 1) return;
+        if (state === 1) return;
         committed.resolve();
       }, [state]);
 

package/src/useLazyDisposableState.ts

@@ -2,7 +2,7 @@
 
 import type { ItemCleanupPair } from '@isograph/isograph-disposable-types';
 import { useEffect, useRef } from 'react';
-import { ParentCache } from './ParentCache';
+import type { ParentCache } from './ParentCache';
 import { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';
 import { type UnassignedState } from './useUpdatableDisposableState';
 

package/src/useUpdatableDisposableState.test.tsx

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { type MutableRefObject } from 'react';
 import { create } from 'react-test-renderer';
 import { describe, expect, test, vi } from 'vitest';
 import {
@@ -6,7 +6,13 @@ import {
   useUpdatableDisposableState,
 } from './useUpdatableDisposableState';
 
-function Suspender({ promise, isResolvedRef }) {
+function Suspender({
+  promise,
+  isResolvedRef,
+}: {
+  isResolvedRef: MutableRefObject<boolean>;
+  promise: Promise<unknown>;
+}) {
   if (!isResolvedRef.current) {
     throw promise;
   }
@@ -43,7 +49,7 @@ 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) {
+async function awaitableCreate(Component, isConcurrent: boolean) {
   const element = create(
     Component,
     isConcurrent ? { unstable_isConcurrent: true } : undefined,
@@ -377,7 +383,11 @@ if (false) {
       }
 
       let setState;
-      function ParentComponent({ shouldMountRef }) {
+      function ParentComponent({
+        shouldMountRef,
+      }: {
+        shouldMountRef: MutableRefObject<boolean>;
+      }) {
         const [, _setState] = React.useState();
         setState = _setState;
         return shouldMountRef.current ? (
@@ -450,7 +460,11 @@ if (false) {
       }
 
       let setState;
-      function ParentComponent({ shouldMountRef }) {
+      function ParentComponent({
+        shouldMountRef,
+      }: {
+        shouldMountRef: MutableRefObject<boolean>;
+      }) {
         const [, _setState] = React.useState();
         setState = _setState;
         return shouldMountRef.current ? <TestComponent /> : null;

package/src/useUpdatableDisposableState.ts

@@ -1,4 +1,4 @@
-import { ItemCleanupPair } from '@isograph/disposable-types';
+import type { ItemCleanupPair } from '@isograph/disposable-types';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { useHasCommittedRef } from './useHasCommittedRef';
 

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAE3C,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,qCAAqC,CAAC;AACpD,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC"}