signalium 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # signalium
 
+## 0.2.1
+
+### Patch Changes
+
+- e8aa91a: Fix async init values
+
 ## 0.2.0
 
 ### Minor Changes

package/dist/signals.d.ts

@@ -76,6 +76,7 @@ export interface AsyncPending<T> extends AsyncBaseResult<T> {
     isReady: false;
     isError: boolean;
     isSuccess: boolean;
+    didResolve: boolean;
 }
 export interface AsyncReady<T> extends AsyncBaseResult<T> {
     result: T;
@@ -84,6 +85,7 @@ export interface AsyncReady<T> extends AsyncBaseResult<T> {
     isReady: true;
     isError: boolean;
     isSuccess: boolean;
+    didResolve: boolean;
 }
 export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;
 declare class StateSignal<T> implements StateSignal<T> {

package/dist/signals.js

@@ -115,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;
@@ -226,34 +257,7 @@ 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,
-                            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;
-                            },
-                        });
+                    const value = this._currentValue;
                     let nextValue;
                     try {
                         CURRENT_IS_WAITING = false;
@@ -294,6 +298,7 @@ export class ComputedSignal {
                             }
                             value.result = result;
                             value.isReady = true;
+                            value.didResolve = true;
                             value.isPending = false;
                             value.isSuccess = true;
                             this._version++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalium",
-  "version": "0.2.0",
+  "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,16 +8,19 @@ 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,
     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>;
@@ -31,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,
     });
@@ -58,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,
     });
@@ -93,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,
     });
@@ -134,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 () => {
@@ -190,7 +230,7 @@ describe('Async Signal functionality', () => {
       });
 
       // 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,
       });
@@ -198,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,
       });
@@ -206,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,
       });
@@ -240,14 +280,14 @@ describe('Async Signal functionality', () => {
       });
 
       // 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', false, 'error'), {
+      expect(compC).toHaveValueAndCounts(result(undefined, 'error', 'initial', 'error'), {
         compute: 2,
         resolve: 0,
       });

package/src/signals.ts

@@ -208,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> {
@@ -350,41 +390,7 @@ export class ComputedSignal<T> {
         }
 
         case SignalType.Async: {
-          const value: AsyncResult<T> =
-            (this._currentValue as AsyncResult<T>) ??
-            (this._currentValue = {
-              result: undefined,
-              error: undefined,
-              isPending: true,
-              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;
-              },
-            });
+          const value: AsyncResult<T> = this._currentValue as AsyncResult<T>;
 
           let nextValue;
 
@@ -431,6 +437,7 @@ export class ComputedSignal<T> {
 
                 value.result = result;
                 value.isReady = true;
+                value.didResolve = true;
 
                 value.isPending = false;
                 value.isSuccess = true;
@@ -639,6 +646,7 @@ export interface AsyncPending<T> extends AsyncBaseResult<T> {
   isReady: false;
   isError: boolean;
   isSuccess: boolean;
+  didResolve: boolean;
 }
 
 export interface AsyncReady<T> extends AsyncBaseResult<T> {
@@ -648,6 +656,7 @@ export interface AsyncReady<T> extends AsyncBaseResult<T> {
   isReady: true;
   isError: boolean;
   isSuccess: boolean;
+  didResolve: boolean;
 }
 
 export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;