signalium 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # signalium
 
+## 0.2.0
+
+### Minor Changes
+
+- 4696d06: Refactor await and invalidate to make them more composable
+
 ## 0.1.1
 
 ### Patch Changes

package/dist/signals.d.ts

@@ -10,10 +10,7 @@ export interface Signal<T = unknown> {
 export interface WriteableSignal<T> extends Signal<T> {
     set(value: T): void;
 }
-export interface AsyncSignal<T> extends Signal<AsyncResult<T>> {
-    invalidate(): void;
-    await(): T;
-}
+export type AsyncSignal<T> = Signal<AsyncResult<T>>;
 export type SignalCompute<T> = (prev: T | undefined) => T;
 export type SignalAsyncCompute<T> = (prev: T | undefined) => T | Promise<T>;
 export type SignalWatcherEffect = () => void;
@@ -61,8 +58,6 @@ export declare class ComputedSignal<T> {
     _ref: WeakRef<ComputedSignal<T>>;
     constructor(type: SignalType, compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T> | undefined, equals?: SignalEquals<T>, initValue?: T);
     get(): T | AsyncResult<T>;
-    invalidate(): void;
-    await(): T;
     _check(shouldWatch?: boolean): number;
     _run(wasConnected: boolean, isConnected: boolean, shouldConnect: boolean): void;
     _resetDirty(): void;
@@ -70,7 +65,11 @@ export declare class ComputedSignal<T> {
     _dirtyConsumers(): void;
     _disconnect(count?: number): void;
 }
-export interface AsyncPending {
+export interface AsyncBaseResult<T> {
+    invalidate(): void;
+    await(): T;
+}
+export interface AsyncPending<T> extends AsyncBaseResult<T> {
     result: undefined;
     error: unknown;
     isPending: boolean;
@@ -78,7 +77,7 @@ export interface AsyncPending {
     isError: boolean;
     isSuccess: boolean;
 }
-export interface AsyncReady<T> {
+export interface AsyncReady<T> extends AsyncBaseResult<T> {
     result: T;
     error: unknown;
     isPending: boolean;
@@ -86,7 +85,7 @@ export interface AsyncReady<T> {
     isError: boolean;
     isSuccess: boolean;
 }
-export type AsyncResult<T> = AsyncPending | AsyncReady<T>;
+export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;
 declare class StateSignal<T> implements StateSignal<T> {
     private _value;
     private _equals;

package/dist/signals.js

@@ -3,10 +3,11 @@ let CURRENT_CONSUMER;
 let CURRENT_DEP_TAIL;
 let CURRENT_ORD = 0;
 let CURRENT_IS_WATCHED = false;
-let CURRENT_WAITING_STATE = false;
+let CURRENT_IS_WAITING = false;
 let CURRENT_SEEN;
 let id = 0;
 const SUBSCRIPTIONS = new WeakMap();
+const ACTIVE_ASYNCS = new WeakMap();
 const WAITING = Symbol();
 let linkPool;
 function linkNewDep(dep, sub, nextDep, depsTail, ord) {
@@ -151,27 +152,6 @@ export class ComputedSignal {
         }
         return this._currentValue;
     }
-    invalidate() {
-        this._state = 2 /* SignalState.Dirty */;
-        this._dirty();
-    }
-    await() {
-        if (this._type !== 2 /* SignalType.Async */) {
-            throw new Error('Cannot await non-async signal');
-        }
-        if (CURRENT_CONSUMER === undefined || CURRENT_CONSUMER._type !== 2 /* SignalType.Async */) {
-            throw new Error('Cannot await an async signal outside of an async signal. If you are using an async function, you must use signal.await() for all async signals _before_ the first language-level `await` keyword statement (e.g. it must be synchronous).');
-        }
-        CURRENT_WAITING_STATE = true;
-        const value = this.get();
-        if (value.isPending) {
-            throw WAITING;
-        }
-        else if (value.isError) {
-            throw value.error;
-        }
-        return value.result;
-    }
     _check(shouldWatch = false) {
         let state = this._state;
         let connectedCount = this._connectedCount;
@@ -254,9 +234,29 @@ export class ComputedSignal {
                             isReady: false,
                             isError: false,
                             isSuccess: false,
+                            invalidate: () => {
+                                this._state = 2 /* SignalState.Dirty */;
+                                this._dirty();
+                            },
+                            await: () => {
+                                if (CURRENT_CONSUMER === undefined || CURRENT_CONSUMER._type !== 2 /* SignalType.Async */) {
+                                    throw new Error('Cannot await an async signal outside of an async signal. If you are using an async function, you must use signal.await() for all async signals _before_ the first language-level `await` keyword statement (e.g. it must be synchronous).');
+                                }
+                                if (value.isPending) {
+                                    const currentConsumer = CURRENT_CONSUMER;
+                                    ACTIVE_ASYNCS.get(this)?.finally(() => currentConsumer._check());
+                                    CURRENT_IS_WAITING = true;
+                                    throw WAITING;
+                                }
+                                else if (value.isError) {
+                                    throw value.error;
+                                }
+                                return value.result;
+                            },
                         });
                     let nextValue;
                     try {
+                        CURRENT_IS_WAITING = false;
                         nextValue = this._compute(value?.result);
                     }
                     catch (e) {
@@ -268,16 +268,15 @@ export class ComputedSignal {
                         }
                         break;
                     }
-                    if (typeof CURRENT_WAITING_STATE !== 'boolean') {
+                    if (CURRENT_IS_WAITING) {
                         if (!value.isPending) {
                             value.isPending = true;
                             value.isError = false;
                             value.isSuccess = false;
                             this._version++;
                         }
-                        CURRENT_WAITING_STATE.finally(() => this._check());
                         if (nextValue instanceof Promise) {
-                            nextValue.catch(e => {
+                            nextValue.catch((e) => {
                                 if (e !== WAITING) {
                                     value.error = e;
                                     value.isPending = false;
@@ -309,9 +308,7 @@ export class ComputedSignal {
                             this._version++;
                             this._dirtyConsumers();
                         });
-                        if (CURRENT_WAITING_STATE === true) {
-                            CURRENT_WAITING_STATE = nextValue;
-                        }
+                        ACTIVE_ASYNCS.set(this, nextValue);
                         value.isPending = true;
                         value.isError = false;
                         value.isSuccess = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalium",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "type": "module",
   "repository": "https://github.com/pzuraq/signalium",
   "description": "Chain-reactivity at critical mass",

package/src/__tests__/async.test.ts

@@ -9,14 +9,17 @@ const result = <T>(
   value: T | undefined,
   promiseState: 'pending' | 'error' | 'success',
   isReady: boolean,
+  error?: any,
 ): AsyncResult<T> =>
   ({
     result: value,
-    error: undefined,
+    error,
     isPending: promiseState === 'pending',
     isReady,
     isError: promiseState === 'error',
     isSuccess: promiseState === 'success',
+    await: expect.any(Function),
+    invalidate: expect.any(Function),
   }) as AsyncResult<T>;
 
 describe('Async Signal functionality', () => {
@@ -180,8 +183,8 @@ describe('Async Signal functionality', () => {
       });
 
       const compC = asyncComputed(async () => {
-        const a = compA.await();
-        const b = compB.await();
+        const a = compA.get().await();
+        const b = compB.get().await();
 
         return a + b;
       });
@@ -230,8 +233,8 @@ describe('Async Signal functionality', () => {
       });
 
       const compC = asyncComputed(async () => {
-        const a = compA.await();
-        const b = compB.await();
+        const a = compA.get().await();
+        const b = compB.get().await();
 
         return a + b;
       });
@@ -244,20 +247,10 @@ describe('Async Signal functionality', () => {
 
       await sleep(50);
 
-      expect(compC).toHaveValueAndCounts(
-        {
-          result: undefined,
-          error: 'error',
-          isPending: false,
-          isReady: false,
-          isError: true,
-          isSuccess: false,
-        },
-        {
-          compute: 2,
-          resolve: 0,
-        },
-      );
+      expect(compC).toHaveValueAndCounts(result(undefined, 'error', false, 'error'), {
+        compute: 2,
+        resolve: 0,
+      });
     });
   });
 });

package/src/__tests__/utils/instrumented.ts

@@ -10,11 +10,9 @@ import {
   WriteableSignal,
   SignalCompute,
   SignalAsyncCompute,
-  AsyncResult,
   SignalSubscribe,
   SignalSubscription,
   SignalOptionsWithInit,
-  AsyncReady,
   Watcher,
   SignalWatcherEffect,
   AsyncSignal,
@@ -226,14 +224,6 @@ export function asyncComputed<T>(
       counts.get++;
       return s.get();
     },
-
-    invalidate() {
-      s.invalidate();
-    },
-
-    await() {
-      return s.await();
-    },
   };
 
   COUNTS.set(wrapper, counts);

package/src/signals.ts

@@ -4,7 +4,7 @@ let CURRENT_CONSUMER: ComputedSignal<any> | undefined;
 let CURRENT_DEP_TAIL: Link | undefined;
 let CURRENT_ORD: number = 0;
 let CURRENT_IS_WATCHED: boolean = false;
-let CURRENT_WAITING_STATE: Promise<unknown> | boolean = false;
+let CURRENT_IS_WAITING: boolean = false;
 let CURRENT_SEEN: WeakSet<ComputedSignal<any>> | undefined;
 
 let id = 0;
@@ -24,10 +24,7 @@ export interface WriteableSignal<T> extends Signal<T> {
   set(value: T): void;
 }
 
-export interface AsyncSignal<T> extends Signal<AsyncResult<T>> {
-  invalidate(): void;
-  await(): T;
-}
+export type AsyncSignal<T> = Signal<AsyncResult<T>>;
 
 export type SignalCompute<T> = (prev: T | undefined) => T;
 
@@ -53,6 +50,7 @@ export interface SignalOptionsWithInit<T> extends SignalOptions<T> {
 }
 
 const SUBSCRIPTIONS = new WeakMap<ComputedSignal<any>, SignalSubscription | undefined | void>();
+const ACTIVE_ASYNCS = new WeakMap<ComputedSignal<any>, Promise<unknown>>();
 
 const enum SignalState {
   Clean,
@@ -259,34 +257,6 @@ export class ComputedSignal<T> {
     return this._currentValue!;
   }
 
-  invalidate() {
-    this._state = SignalState.Dirty;
-    this._dirty();
-  }
-
-  await() {
-    if (this._type !== SignalType.Async) {
-      throw new Error('Cannot await non-async signal');
-    }
-
-    if (CURRENT_CONSUMER === undefined || CURRENT_CONSUMER._type !== SignalType.Async) {
-      throw new Error(
-        'Cannot await an async signal outside of an async signal. If you are using an async function, you must use signal.await() for all async signals _before_ the first language-level `await` keyword statement (e.g. it must be synchronous).',
-      );
-    }
-
-    CURRENT_WAITING_STATE = true;
-    const value = this.get() as AsyncResult<T>;
-
-    if (value.isPending) {
-      throw WAITING;
-    } else if (value.isError) {
-      throw value.error;
-    }
-
-    return value.result as T;
-  }
-
   _check(shouldWatch = false): number {
     let state = this._state;
     let connectedCount = this._connectedCount;
@@ -380,7 +350,7 @@ export class ComputedSignal<T> {
         }
 
         case SignalType.Async: {
-          const value =
+          const value: AsyncResult<T> =
             (this._currentValue as AsyncResult<T>) ??
             (this._currentValue = {
               result: undefined,
@@ -389,11 +359,37 @@ export class ComputedSignal<T> {
               isReady: false,
               isError: false,
               isSuccess: false,
+
+              invalidate: () => {
+                this._state = SignalState.Dirty;
+                this._dirty();
+              },
+
+              await: () => {
+                if (CURRENT_CONSUMER === undefined || CURRENT_CONSUMER._type !== SignalType.Async) {
+                  throw new Error(
+                    'Cannot await an async signal outside of an async signal. If you are using an async function, you must use signal.await() for all async signals _before_ the first language-level `await` keyword statement (e.g. it must be synchronous).',
+                  );
+                }
+
+                if (value.isPending) {
+                  const currentConsumer = CURRENT_CONSUMER;
+                  ACTIVE_ASYNCS.get(this)?.finally(() => currentConsumer._check());
+
+                  CURRENT_IS_WAITING = true;
+                  throw WAITING;
+                } else if (value.isError) {
+                  throw value.error;
+                }
+
+                return value.result as T;
+              },
             });
 
           let nextValue;
 
           try {
+            CURRENT_IS_WAITING = false;
             nextValue = (this._compute as SignalAsyncCompute<T>)(value?.result);
           } catch (e) {
             if (e !== WAITING) {
@@ -406,7 +402,7 @@ export class ComputedSignal<T> {
             break;
           }
 
-          if (typeof CURRENT_WAITING_STATE !== 'boolean') {
+          if (CURRENT_IS_WAITING) {
             if (!value.isPending) {
               value.isPending = true;
               value.isError = false;
@@ -414,10 +410,8 @@ export class ComputedSignal<T> {
               this._version++;
             }
 
-            CURRENT_WAITING_STATE.finally(() => this._check());
-
             if (nextValue instanceof Promise) {
-              nextValue.catch(e => {
+              nextValue.catch((e: unknown) => {
                 if (e !== WAITING) {
                   value.error = e;
                   value.isPending = false;
@@ -457,9 +451,7 @@ export class ComputedSignal<T> {
               },
             );
 
-            if (CURRENT_WAITING_STATE === true) {
-              CURRENT_WAITING_STATE = nextValue;
-            }
+            ACTIVE_ASYNCS.set(this, nextValue);
 
             value.isPending = true;
             value.isError = false;
@@ -635,7 +627,12 @@ export class ComputedSignal<T> {
   }
 }
 
-export interface AsyncPending {
+export interface AsyncBaseResult<T> {
+  invalidate(): void;
+  await(): T;
+}
+
+export interface AsyncPending<T> extends AsyncBaseResult<T> {
   result: undefined;
   error: unknown;
   isPending: boolean;
@@ -644,7 +641,7 @@ export interface AsyncPending {
   isSuccess: boolean;
 }
 
-export interface AsyncReady<T> {
+export interface AsyncReady<T> extends AsyncBaseResult<T> {
   result: T;
   error: unknown;
   isPending: boolean;
@@ -653,7 +650,7 @@ export interface AsyncReady<T> {
   isSuccess: boolean;
 }
 
-export type AsyncResult<T> = AsyncPending | AsyncReady<T>;
+export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;
 
 class StateSignal<T> implements StateSignal<T> {
   private _consumers: WeakRef<ComputedSignal<unknown>>[] = [];