signalium 0.2.2 → 0.2.4

package/src/__tests__/async.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { state, asyncComputed } from './utils/instrumented.js';
+import { state, asyncComputed, computed } from './utils/instrumented.js';
 import { AsyncResult } from '../signals';
 
 const sleep = (ms = 0) => new Promise(r => setTimeout(r, ms));
@@ -131,7 +131,7 @@ describe('Async Signal functionality', () => {
       const result = a.get() + b.get();
 
       if (result === 4) {
-        await sleep(100);
+        await sleep(10);
       }
 
       return result;
@@ -163,7 +163,7 @@ describe('Async Signal functionality', () => {
       resolve: 1,
     });
 
-    await sleep(200);
+    await sleep(20);
 
     expect(c).toHaveValueAndCounts(result(5, 'success', 'resolved'), {
       compute: 3,
@@ -179,7 +179,7 @@ describe('Async Signal functionality', () => {
       async () => {
         const result = a.get() + b.get();
 
-        await sleep(50);
+        await sleep(10);
 
         return result;
       },
@@ -200,7 +200,7 @@ describe('Async Signal functionality', () => {
       resolve: 0,
     });
 
-    await sleep(60);
+    await sleep(20);
 
     expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
@@ -211,13 +211,13 @@ describe('Async Signal functionality', () => {
   describe('Awaiting', () => {
     test('Awaiting a computed will resolve the value', async () => {
       const compA = asyncComputed(async () => {
-        await sleep(20);
+        await sleep(10);
 
         return 1;
       });
 
       const compB = asyncComputed(async () => {
-        await sleep(20);
+        await sleep(10);
 
         return 2;
       });
@@ -243,7 +243,7 @@ describe('Async Signal functionality', () => {
         resolve: 0,
       });
 
-      await sleep(30);
+      await sleep(20);
 
       // Check to make sure we don't resolve early after the first task completes
       expect(compC).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
@@ -251,7 +251,7 @@ describe('Async Signal functionality', () => {
         resolve: 0,
       });
 
-      await sleep(30);
+      await sleep(20);
 
       expect(compC).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
         compute: 3,
@@ -261,7 +261,7 @@ describe('Async Signal functionality', () => {
 
     test('Awaiting a computed can handle errors', async () => {
       const compA = asyncComputed(async () => {
-        await sleep(20);
+        await sleep(10);
 
         throw 'error';
       });
@@ -285,12 +285,142 @@ describe('Async Signal functionality', () => {
         resolve: 0,
       });
 
-      await sleep(50);
+      await sleep(15);
 
       expect(compC).toHaveValueAndCounts(result(undefined, 'error', 'initial', 'error'), {
         compute: 2,
         resolve: 0,
       });
     });
+
+    test('Awaiting a computed does not let valid values override errors', async () => {
+      const compA = asyncComputed(async () => {
+        await sleep(10);
+
+        throw 'error';
+      });
+
+      const compB = asyncComputed(async () => {
+        await sleep(20);
+
+        return 2;
+      });
+
+      const compC = asyncComputed(async () => {
+        const aResult = compA.get();
+        const bResult = compB.get();
+
+        const b = bResult.await();
+        const a = aResult.await();
+
+        return a + b;
+      });
+
+      // Pull once to start the computation, trigger the computation
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
+        compute: 1,
+        resolve: 0,
+      });
+
+      await sleep(40);
+
+      expect(compC).toHaveValueAndCounts(result(undefined, 'error', 'initial', 'error'), {
+        compute: 2,
+        resolve: 0,
+      });
+    });
+
+    test('Await can be composed and nested', async () => {
+      const compA = asyncComputed('compA', async () => {
+        await sleep(20);
+        return 1;
+      });
+
+      const compB = asyncComputed('compB', async () => {
+        await sleep(20);
+        return 2;
+      });
+
+      const compC = computed('compC', () => {
+        const resultA = compA.get();
+        const resultB = compB.get();
+
+        return {
+          awaitA: resultA.await,
+          awaitB: resultB.await,
+        };
+      });
+
+      const compD = asyncComputed('compD', async () => {
+        const { awaitA, awaitB } = compC.get();
+        const a = awaitA();
+        const b = awaitB();
+
+        return a + b;
+      });
+
+      // Pull once to start the computation, trigger the computation
+      expect(compD).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
+        compute: 1,
+        resolve: 0,
+      });
+
+      await sleep(30);
+
+      expect(compD).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
+        compute: 2,
+        resolve: 1,
+      });
+    });
+
+    test('Await works with intermediate state', async () => {
+      const compA = asyncComputed('compA', async () => {
+        await sleep(20);
+        return 1;
+      });
+
+      const compB = asyncComputed('compB', async () => {
+        await sleep(40);
+        return 2;
+      });
+
+      const compC = computed('compC', () => {
+        const resultA = compA.get();
+        const resultB = compB.get();
+
+        return {
+          awaitA: resultA.await,
+          awaitB: resultB.await,
+        };
+      });
+
+      const compD = asyncComputed('compD', async () => {
+        const { awaitA, awaitB } = compC.get();
+        const a = awaitA();
+        const b = awaitB();
+
+        return a + b;
+      });
+
+      // Pull once to start the computation, trigger the computation
+      expect(compD).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
+        compute: 1,
+        resolve: 0,
+      });
+
+      await sleep(30);
+
+      expect(compD).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
+        compute: 2,
+        resolve: 0,
+      });
+
+      await sleep(30);
+
+      expect(compD).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
+        compute: 3,
+        resolve: 1,
+      });
+    });
   });
 });

package/src/__tests__/subscription.test.ts

@@ -227,7 +227,7 @@ describe('Subscription Signal functionality', () => {
       await nextTick();
 
       expect(w).toHaveCounts({ effect: 2 });
-      expect(c).toHaveCounts({ get: 2, compute: 1 });
+      expect(c).toHaveValueAndCounts(123, { get: 3, compute: 1 });
       expect(s).toHaveValueAndCounts(123, {
         subscribe: 1,
       });
@@ -393,7 +393,7 @@ describe('Subscription Signal functionality', () => {
 
           return {
             update() {
-              set(a.get() + 1);
+              set(a.get());
             },
           };
         },
@@ -419,7 +419,7 @@ describe('Subscription Signal functionality', () => {
 
       await nextTick();
 
-      expect(s).toHaveValueAndCounts(2, {
+      expect(s).toHaveValueAndCounts(1, {
         subscribe: 1,
         update: 1,
       });

package/src/__tests__/utils/instrumented.ts

@@ -1,4 +1,4 @@
-import { expect } from 'vitest';
+import { expect, beforeEach, afterEach, vi } from 'vitest';
 import {
   state as createState,
   computed as createComputed,
@@ -187,12 +187,12 @@ export function computed<T>(
   return wrapper;
 }
 
-export function asyncComputed<T>(name: string, compute: SignalAsyncCompute<T>, opts?: SignalOptions<T>): Signal<T>;
+export function asyncComputed<T>(name: string, compute: SignalAsyncCompute<T>, opts?: SignalOptions<T>): AsyncSignal<T>;
 export function asyncComputed<T>(
   name: string,
   compute: SignalAsyncCompute<T>,
   opts: SignalOptionsWithInit<T>,
-): Signal<T>;
+): AsyncSignal<T>;
 export function asyncComputed<T>(compute: SignalAsyncCompute<T>, opts?: SignalOptions<T>): AsyncSignal<T>;
 export function asyncComputed<T>(compute: SignalAsyncCompute<T>, opts: SignalOptionsWithInit<T>): AsyncSignal<T>;
 export function asyncComputed<T>(

package/src/config.ts

@@ -1,27 +1,27 @@
-let currentWatcherFlush: ReturnType<typeof setTimeout> | null = null;
-let currentDisconnectFlush: ReturnType<typeof setTimeout> | ReturnType<typeof requestIdleCallback> | null = null;
+let currentFlush: ReturnType<typeof setTimeout> | null = null;
 
 export type FlushCallback = () => Promise<void>;
 
-const idleCallback =
-  typeof requestIdleCallback === 'function' ? requestIdleCallback : (cb: () => void) => setTimeout(cb, 0);
+export type FlushFn = (fn: () => Promise<void>) => void;
 
-export let scheduleWatchers: (flushWatchers: FlushCallback) => void = flushWatchers => {
-  if (currentWatcherFlush !== null) return;
+export let scheduleFlush: FlushFn = flushWatchers => {
+  if (currentFlush !== null) return;
 
-  currentWatcherFlush = setTimeout(() => {
-    currentWatcherFlush = null;
+  currentFlush = setTimeout(() => {
+    currentFlush = null;
 
     flushWatchers();
   }, 0);
 };
 
-export let scheduleDisconnects: (flushDisconnects: FlushCallback) => void = flushDisconnects => {
-  if (currentDisconnectFlush !== null) return;
+export const setScheduleFlush = (flushFn: FlushFn) => {
+  scheduleFlush = flushFn;
+};
+
+export type BatchFn = (fn: () => void) => void;
 
-  currentDisconnectFlush = idleCallback(() => {
-    currentDisconnectFlush = null;
+export let runBatch: BatchFn = fn => fn();
 
-    flushDisconnects();
-  });
+export const setRunBatch = (batchFn: BatchFn) => {
+  runBatch = batchFn;
 };

package/src/scheduling.ts

@@ -1,39 +1,26 @@
-import type { ComputedSignal } from './signals.js';
-import { scheduleWatchers, scheduleDisconnects } from './config.js';
+import { ComputedSignal } from './signals.js';
+import { scheduleFlush, runBatch } from './config.js';
 
-let PENDING_FLUSH_WATCHERS: {
-  promise: Promise<void>;
-  resolve: () => void;
-} | null = null;
+let PENDING_DIRTIES: ComputedSignal<any>[] = [];
+let PENDING_PULLS: ComputedSignal<any>[] = [];
+let PENDING_WATCHERS: ComputedSignal<any>[] = [];
+let PENDING_DISCONNECTS = new Map<ComputedSignal<any>, number>();
 
-const PENDING_WATCHERS: ComputedSignal<any>[] = [];
-const PENDING_DISCONNECTS: Map<ComputedSignal<any>, number> = new Map();
+const microtask = () => Promise.resolve();
 
 export const scheduleWatcher = (watcher: ComputedSignal<any>) => {
   PENDING_WATCHERS.push(watcher);
-
-  if (PENDING_FLUSH_WATCHERS === null) {
-    let resolve: () => void;
-
-    const promise = new Promise<void>(r => {
-      resolve = r;
-    });
-
-    PENDING_FLUSH_WATCHERS = { promise, resolve: resolve! };
-  }
-
-  scheduleWatchers(flushWatchers);
+  scheduleFlush(flushWatchers);
 };
 
-const flushWatchers = async () => {
-  PENDING_FLUSH_WATCHERS!.resolve();
-  PENDING_FLUSH_WATCHERS = null;
-  let watcher;
-  while ((watcher = PENDING_WATCHERS.shift())) {
-    watcher._check();
-  }
+export const scheduleDirty = (signal: ComputedSignal<any>) => {
+  PENDING_DIRTIES.push(signal);
+  scheduleFlush(flushWatchers);
+};
 
-  PENDING_WATCHERS.length = 0;
+export const schedulePull = (signal: ComputedSignal<any>) => {
+  PENDING_PULLS.push(signal);
+  scheduleFlush(flushWatchers);
 };
 
 export const scheduleDisconnect = (disconnect: ComputedSignal<any>) => {
@@ -41,14 +28,35 @@ export const scheduleDisconnect = (disconnect: ComputedSignal<any>) => {
 
   PENDING_DISCONNECTS.set(disconnect, current + 1);
 
-  scheduleDisconnects(flushDisconnects);
+  scheduleFlush(flushWatchers);
 };
 
-const flushDisconnects = async () => {
-  await PENDING_FLUSH_WATCHERS?.promise;
-  for (const [signal, count] of PENDING_DISCONNECTS) {
-    signal._disconnect(count);
+const flushWatchers = async () => {
+  while (PENDING_DIRTIES.length > 0 || PENDING_PULLS.length > 0) {
+    for (const dirty of PENDING_DIRTIES) {
+      dirty._dirtyConsumers();
+    }
+
+    for (const pull of PENDING_PULLS) {
+      pull._check();
+    }
+
+    PENDING_DIRTIES = [];
+    PENDING_PULLS = [];
+
+    await microtask();
   }
 
-  PENDING_DISCONNECTS.clear();
+  runBatch(() => {
+    for (const watcher of PENDING_WATCHERS) {
+      watcher._check();
+    }
+
+    for (const [signal, count] of PENDING_DISCONNECTS) {
+      signal._disconnect(count);
+    }
+
+    PENDING_WATCHERS = [];
+    PENDING_DISCONNECTS.clear();
+  });
 };