signalium 0.1.1 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # signalium
 
+## 0.2.1
+
+### Patch Changes
+
+- e8aa91a: Fix async init values
+
+## 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,23 +65,29 @@ 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;
     isReady: false;
     isError: boolean;
     isSuccess: boolean;
+    didResolve: boolean;
 }
-export interface AsyncReady<T> {
+export interface AsyncReady<T> extends AsyncBaseResult<T> {
     result: T;
     error: unknown;
     isPending: boolean;
     isReady: true;
     isError: boolean;
     isSuccess: boolean;
+    didResolve: 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) {
@@ -114,8 +115,39 @@ export class ComputedSignal {
         this._type = type;
         this._compute = compute;
         this._equals = equals ?? ((a, b) => a === b);
-        this._currentValue = initValue;
         this._connectedCount = type === 3 /* SignalType.Watcher */ ? 1 : 0;
+        this._currentValue =
+            type !== 2 /* SignalType.Async */
+                ? initValue
+                : {
+                    result: initValue,
+                    error: undefined,
+                    isReady: initValue !== undefined,
+                    isPending: true,
+                    isError: false,
+                    isSuccess: false,
+                    didResolve: 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).');
+                        }
+                        const value = this._currentValue;
+                        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;
+                    },
+                };
     }
     get() {
         let prevTracked = false;
@@ -151,27 +183,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;
@@ -246,17 +257,10 @@ export class ComputedSignal {
                     break;
                 }
                 case 2 /* SignalType.Async */: {
-                    const value = this._currentValue ??
-                        (this._currentValue = {
-                            result: undefined,
-                            error: undefined,
-                            isPending: true,
-                            isReady: false,
-                            isError: false,
-                            isSuccess: false,
-                        });
+                    const value = this._currentValue;
                     let nextValue;
                     try {
+                        CURRENT_IS_WAITING = false;
                         nextValue = this._compute(value?.result);
                     }
                     catch (e) {
@@ -268,16 +272,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;
@@ -295,6 +298,7 @@ export class ComputedSignal {
                             }
                             value.result = result;
                             value.isReady = true;
+                            value.didResolve = true;
                             value.isPending = false;
                             value.isSuccess = true;
                             this._version++;
@@ -309,9 +313,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.1",
   "type": "module",
   "repository": "https://github.com/pzuraq/signalium",
   "description": "Chain-reactivity at critical mass",

package/src/__tests__/async.test.ts

@@ -8,15 +8,21 @@ const nextTick = () => new Promise(r => setTimeout(r, 0));
 const result = <T>(
   value: T | undefined,
   promiseState: 'pending' | 'error' | 'success',
-  isReady: boolean,
+  readyState: 'initial' | 'ready' | 'resolved',
+  error?: any,
 ): AsyncResult<T> =>
   ({
     result: value,
-    error: undefined,
+    error,
     isPending: promiseState === 'pending',
-    isReady,
     isError: promiseState === 'error',
     isSuccess: promiseState === 'success',
+
+    isReady: readyState === 'ready' || readyState === 'resolved',
+    didResolve: readyState === 'resolved',
+
+    await: expect.any(Function),
+    invalidate: expect.any(Function),
   }) as AsyncResult<T>;
 
 describe('Async Signal functionality', () => {
@@ -28,20 +34,20 @@ describe('Async Signal functionality', () => {
       return a.get() + b.get();
     });
 
-    expect(c).toHaveValueAndCounts(result(undefined, 'pending', false), {
+    expect(c).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
       compute: 1,
       resolve: 0,
     });
 
     await nextTick();
 
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
 
     // stability
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
@@ -55,28 +61,28 @@ describe('Async Signal functionality', () => {
       return a.get() + b.get();
     });
 
-    expect(c).toHaveValueAndCounts(result(undefined, 'pending', false), {
+    expect(c).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
       compute: 1,
       resolve: 0,
     });
 
     await nextTick();
 
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
 
     a.set(2);
 
-    expect(c).toHaveValueAndCounts(result(3, 'pending', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'pending', 'resolved'), {
       compute: 2,
       resolve: 1,
     });
 
     await nextTick();
 
-    expect(c).toHaveValueAndCounts(result(4, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(4, 'success', 'resolved'), {
       compute: 2,
       resolve: 2,
     });
@@ -90,28 +96,28 @@ describe('Async Signal functionality', () => {
       return a.get() + b.get();
     });
 
-    expect(c).toHaveValueAndCounts(result(undefined, 'pending', false), {
+    expect(c).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
       compute: 1,
       resolve: 0,
     });
 
     await nextTick();
 
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
 
     a.set(1);
 
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
 
     await nextTick();
 
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
@@ -131,40 +137,77 @@ describe('Async Signal functionality', () => {
       return result;
     });
 
-    expect(c).toHaveValueAndCounts(result(undefined, 'pending', false), {
+    expect(c).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
       compute: 1,
       resolve: 0,
     });
 
     await nextTick();
 
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
 
     a.set(2);
 
-    expect(c).toHaveValueAndCounts(result(3, 'pending', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'pending', 'resolved'), {
       compute: 2,
       resolve: 1,
     });
 
     a.set(3);
 
-    expect(c).toHaveValueAndCounts(result(3, 'pending', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'pending', 'resolved'), {
       compute: 3,
       resolve: 1,
     });
 
     await sleep(200);
 
-    expect(c).toHaveValueAndCounts(result(5, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(5, 'success', 'resolved'), {
       compute: 3,
       resolve: 3,
     });
   });
 
+  test('Can have initial value', async () => {
+    const a = state(1);
+    const b = state(2);
+
+    const c = asyncComputed(
+      async () => {
+        const result = a.get() + b.get();
+
+        await sleep(50);
+
+        return result;
+      },
+      {
+        initValue: 5,
+      },
+    );
+
+    expect(c).toHaveValueAndCounts(result(5, 'pending', 'ready'), {
+      compute: 1,
+      resolve: 0,
+    });
+
+    await nextTick();
+
+    expect(c).toHaveValueAndCounts(result(5, 'pending', 'ready'), {
+      compute: 1,
+      resolve: 0,
+    });
+
+    await sleep(60);
+
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
+      compute: 1,
+      resolve: 1,
+    });
+  });
+
   describe('Awaiting', () => {
     test('Awaiting a computed will resolve the value', async () => {
       const compA = asyncComputed(async () => {
@@ -180,14 +223,14 @@ 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;
       });
 
       // Pull once to start the computation, trigger the computation
-      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
         compute: 1,
         resolve: 0,
       });
@@ -195,7 +238,7 @@ describe('Async Signal functionality', () => {
       await nextTick();
 
       // Check after a tick to make sure we didn't resolve early
-      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
         compute: 1,
         resolve: 0,
       });
@@ -203,14 +246,14 @@ describe('Async Signal functionality', () => {
       await sleep(30);
 
       // Check to make sure we don't resolve early after the first task completes
-      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
         compute: 2,
         resolve: 0,
       });
 
       await sleep(30);
 
-      expect(compC).toHaveValueAndCounts(result(3, 'success', true), {
+      expect(compC).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
         compute: 3,
         resolve: 1,
       });
@@ -230,34 +273,24 @@ 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;
       });
 
       // Pull once to start the computation, trigger the computation
-      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
         compute: 1,
         resolve: 0,
       });
 
       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', 'initial', '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,
@@ -210,8 +208,48 @@ export class ComputedSignal<T> {
     this._type = type;
     this._compute = compute;
     this._equals = equals ?? ((a, b) => a === b);
-    this._currentValue = initValue;
     this._connectedCount = type === SignalType.Watcher ? 1 : 0;
+
+    this._currentValue =
+      type !== SignalType.Async
+        ? initValue
+        : ({
+            result: initValue,
+            error: undefined,
+            isReady: initValue !== undefined,
+
+            isPending: true,
+            isError: false,
+            isSuccess: false,
+            didResolve: 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).',
+                );
+              }
+
+              const value = this._currentValue as AsyncResult<T>;
+
+              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;
+            },
+          } as AsyncResult<T>);
   }
 
   get(): T | AsyncResult<T> {
@@ -259,34 +297,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,20 +390,12 @@ export class ComputedSignal<T> {
         }
 
         case SignalType.Async: {
-          const value =
-            (this._currentValue as AsyncResult<T>) ??
-            (this._currentValue = {
-              result: undefined,
-              error: undefined,
-              isPending: true,
-              isReady: false,
-              isError: false,
-              isSuccess: false,
-            });
+          const value: AsyncResult<T> = this._currentValue as AsyncResult<T>;
 
           let nextValue;
 
           try {
+            CURRENT_IS_WAITING = false;
             nextValue = (this._compute as SignalAsyncCompute<T>)(value?.result);
           } catch (e) {
             if (e !== WAITING) {
@@ -406,7 +408,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 +416,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;
@@ -437,6 +437,7 @@ export class ComputedSignal<T> {
 
                 value.result = result;
                 value.isReady = true;
+                value.didResolve = true;
 
                 value.isPending = false;
                 value.isSuccess = true;
@@ -457,9 +458,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,25 +634,32 @@ 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;
   isReady: false;
   isError: boolean;
   isSuccess: boolean;
+  didResolve: boolean;
 }
 
-export interface AsyncReady<T> {
+export interface AsyncReady<T> extends AsyncBaseResult<T> {
   result: T;
   error: unknown;
   isPending: boolean;
   isReady: true;
   isError: boolean;
   isSuccess: boolean;
+  didResolve: 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>>[] = [];