refactor: relocate the async iterable channel utility into the common dir (#51)

Author: shtaif

src/useAsyncIterState/IterableChannel.ts renamed to src/common/AsyncIterableChannel.ts

@@ -1,10 +1,11 @@
 import { type MutableRefObject } from 'react';
-import { promiseWithResolvers } from '../common/promiseWithResolvers.js';
-import { callWithArgsOrReturn } from '../common/callWithArgsOrReturn.js';
+import { type MaybeFunction } from './MaybeFunction.js';
+import { promiseWithResolvers } from './promiseWithResolvers.js';
+import { callWithArgsOrReturn } from './callWithArgsOrReturn.js';
 
-export { IterableChannel, type AsyncIterableSubject };
+export { AsyncIterableChannel, type AsyncIterableSubject };
 
-class IterableChannel<T, TInit = T> {
+class AsyncIterableChannel<T, TInit = T> {
   #isClosed = false;
   #nextIteration = promiseWithResolvers<IteratorResult<T, void>>();
   #currentValue: T | TInit;
@@ -13,23 +14,24 @@ class IterableChannel<T, TInit = T> {
     this.#currentValue = initialValue;
   }
 
-  put(update: T | ((prevState: T | TInit) => T)): void {
-    if (!this.#isClosed) {
-      (async () => {
-        this.#currentValue = callWithArgsOrReturn(update, this.#currentValue);
-        await undefined; // Deferring to the next microtick so that an attempt to pull the a value before making multiple rapid synchronous calls to `put()` will make that pull ultimately yield only the last value that was put - instead of the first one as were if this otherwise wasn't deferred.
-        this.#nextIteration.resolve({ done: false, value: this.#currentValue });
-        this.#nextIteration = promiseWithResolvers();
-      })();
+  put(update: MaybeFunction<T, [prevState: T | TInit]>): void {
+    if (this.#isClosed) {
+      return;
     }
+    (async () => {
+      this.#currentValue = callWithArgsOrReturn(update, this.#currentValue);
+      await undefined; // Deferring to the next microtick so that an attempt to pull the a value before making multiple rapid synchronous calls to `put()` will make that pull ultimately yield only the last value that was put - instead of the first one as were if this otherwise wasn't deferred.
+      this.#nextIteration.resolve({ done: false, value: this.#currentValue });
+      this.#nextIteration = promiseWithResolvers();
+    })();
   }
 
   close(): void {
     this.#isClosed = true;
     this.#nextIteration.resolve({ done: true, value: undefined });
   }
 
-  values: AsyncIterableSubject<T, TInit> = {
+  out: AsyncIterableSubject<T, TInit> = {
     value: (() => {
       const self = this;
       return {

src/useAsyncIterState/index.ts

@@ -1,8 +1,9 @@
 import { useEffect } from 'react';
 import { callOrReturn } from '../common/callOrReturn.js';
 import { useRefWithInitialValue } from '../common/hooks/useRefWithInitialValue.js';
+import { type MaybeFunction } from '../common/MaybeFunction.js';
 import { type Iterate } from '../Iterate/index.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
-import { IterableChannel, type AsyncIterableSubject } from './IterableChannel.js';
+import { AsyncIterableChannel, type AsyncIterableSubject } from '../common/AsyncIterableChannel.js';
 
 export { useAsyncIterState, type AsyncIterStateResult, type AsyncIterableSubject };
 
@@ -99,25 +100,25 @@ export { useAsyncIterState, type AsyncIterStateResult, type AsyncIterableSubject
 function useAsyncIterState<TVal>(): AsyncIterStateResult<TVal, undefined>;
 
 function useAsyncIterState<TVal>(
-  initialValue: TVal | (() => TVal)
+  initialValue: MaybeFunction<TVal>
 ): AsyncIterStateResult<TVal, TVal>;
 
 function useAsyncIterState<TVal, TInitVal = undefined>(
-  initialValue: TInitVal | (() => TInitVal)
+  initialValue: MaybeFunction<TInitVal>
 ): AsyncIterStateResult<TVal, TInitVal>;
 
 function useAsyncIterState<TVal, TInitVal>(
-  initialValue?: TInitVal | (() => TInitVal)
+  initialValue?: MaybeFunction<TInitVal>
 ): AsyncIterStateResult<TVal, TInitVal> {
   const ref = useRefWithInitialValue<{
-    channel: IterableChannel<TVal, TInitVal>;
+    channel: AsyncIterableChannel<TVal, TInitVal>;
     result: AsyncIterStateResult<TVal, TInitVal>;
   }>(() => {
     const initialValueCalced = callOrReturn(initialValue) as TInitVal;
-    const channel = new IterableChannel<TVal, TInitVal>(initialValueCalced);
+    const channel = new AsyncIterableChannel<TVal, TInitVal>(initialValueCalced);
     return {
       channel,
-      result: [channel.values, newVal => channel.put(newVal)],
+      result: [channel.out, newVal => channel.put(newVal)],
     };
   });