signalium 0.2.3 → 0.2.5

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # signalium
 
+## 0.2.5
+
+### Patch Changes
+
+- 4ee723a: Add main entry to package.json
+
+## 0.2.4
+
+### Patch Changes
+
+- c2af4d0: Refactor scheduling, add batching for React Native
+
 ## 0.2.3
 
 ### Patch Changes

package/dist/config.d.ts

@@ -1,3 +1,7 @@
 export type FlushCallback = () => Promise<void>;
-export declare let scheduleWatchers: (flushWatchers: FlushCallback) => void;
-export declare let scheduleDisconnects: (flushDisconnects: FlushCallback) => void;
+export type FlushFn = (fn: () => Promise<void>) => void;
+export declare let scheduleFlush: FlushFn;
+export declare const setScheduleFlush: (flushFn: FlushFn) => void;
+export type BatchFn = (fn: () => void) => void;
+export declare let runBatch: BatchFn;
+export declare const setRunBatch: (batchFn: BatchFn) => void;

package/dist/config.js

@@ -1,19 +1,16 @@
-let currentWatcherFlush = null;
-let currentDisconnectFlush = null;
-const idleCallback = typeof requestIdleCallback === 'function' ? requestIdleCallback : (cb) => setTimeout(cb, 0);
-export let scheduleWatchers = flushWatchers => {
-    if (currentWatcherFlush !== null)
+let currentFlush = null;
+export let scheduleFlush = flushWatchers => {
+    if (currentFlush !== null)
         return;
-    currentWatcherFlush = setTimeout(() => {
-        currentWatcherFlush = null;
+    currentFlush = setTimeout(() => {
+        currentFlush = null;
         flushWatchers();
     }, 0);
 };
-export let scheduleDisconnects = flushDisconnects => {
-    if (currentDisconnectFlush !== null)
-        return;
-    currentDisconnectFlush = idleCallback(() => {
-        currentDisconnectFlush = null;
-        flushDisconnects();
-    });
+export const setScheduleFlush = (flushFn) => {
+    scheduleFlush = flushFn;
+};
+export let runBatch = fn => fn();
+export const setRunBatch = (batchFn) => {
+    runBatch = batchFn;
 };

package/dist/scheduling.d.ts

@@ -1,3 +1,5 @@
-import type { ComputedSignal } from './signals.js';
+import { ComputedSignal } from './signals.js';
 export declare const scheduleWatcher: (watcher: ComputedSignal<any>) => void;
+export declare const scheduleDirty: (signal: ComputedSignal<any>) => void;
+export declare const schedulePull: (signal: ComputedSignal<any>) => void;
 export declare const scheduleDisconnect: (disconnect: ComputedSignal<any>) => void;

package/dist/scheduling.js

@@ -1,36 +1,46 @@
-import { scheduleWatchers, scheduleDisconnects } from './config.js';
-let PENDING_FLUSH_WATCHERS = null;
-const PENDING_WATCHERS = [];
-const PENDING_DISCONNECTS = new Map();
+import { scheduleFlush, runBatch } from './config.js';
+let PENDING_DIRTIES = [];
+let PENDING_PULLS = [];
+let PENDING_WATCHERS = [];
+let PENDING_DISCONNECTS = new Map();
+const microtask = () => Promise.resolve();
 export const scheduleWatcher = (watcher) => {
     PENDING_WATCHERS.push(watcher);
-    if (PENDING_FLUSH_WATCHERS === null) {
-        let resolve;
-        const promise = new Promise(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();
-    }
-    PENDING_WATCHERS.length = 0;
+export const scheduleDirty = (signal) => {
+    PENDING_DIRTIES.push(signal);
+    scheduleFlush(flushWatchers);
+};
+export const schedulePull = (signal) => {
+    PENDING_PULLS.push(signal);
+    scheduleFlush(flushWatchers);
 };
 export const scheduleDisconnect = (disconnect) => {
     const current = PENDING_DISCONNECTS.get(disconnect) ?? 0;
     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();
+    });
 };

package/dist/signals.js

@@ -1,4 +1,5 @@
-import { scheduleDisconnect, scheduleWatcher } from './scheduling.js';
+import { scheduleDirty, scheduleDisconnect, schedulePull, scheduleWatcher } from './scheduling.js';
+import WeakRef from './weakref.js';
 let CURRENT_ORD = 0;
 let CURRENT_CONSUMER;
 let CURRENT_IS_WAITING = false;
@@ -47,7 +48,7 @@ export class ComputedSignal {
                         const value = this._currentValue;
                         if (value.isPending) {
                             const currentConsumer = CURRENT_CONSUMER;
-                            ACTIVE_ASYNCS.get(this)?.finally(() => currentConsumer._check());
+                            ACTIVE_ASYNCS.get(this)?.finally(() => schedulePull(currentConsumer));
                             CURRENT_IS_WAITING = true;
                             throw WAITING;
                         }
@@ -198,7 +199,7 @@ export class ComputedSignal {
                             value.isPending = false;
                             value.isSuccess = true;
                             this._version++;
-                            this._dirtyConsumers();
+                            scheduleDirty(this);
                         }, error => {
                             if (currentVersion !== this._version || error === WAITING) {
                                 return;
@@ -207,7 +208,7 @@ export class ComputedSignal {
                             value.isPending = false;
                             value.isError = true;
                             this._version++;
-                            this._dirtyConsumers();
+                            scheduleDirty(this);
                         });
                         ACTIVE_ASYNCS.set(this, nextValue);
                         value.isPending = true;

package/dist/weakref.d.ts

@@ -0,0 +1,2 @@
+declare const _default: WeakRefConstructor;
+export default _default;

package/dist/weakref.js

@@ -0,0 +1,10 @@
+class WeakRefPolyfill {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    deref() {
+        return this.value;
+    }
+}
+export default typeof WeakRef === 'function' ? WeakRef : WeakRefPolyfill;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "signalium",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "type": "module",
   "repository": "https://github.com/pzuraq/signalium",
   "description": "Chain-reactivity at critical mass",
+  "main": "./dist/index.js",
   "exports": {
     ".": {
       "import": {

package/src/__tests__/async.test.ts

@@ -243,7 +243,7 @@ describe('Async Signal functionality', () => {
         resolve: 0,
       });
 
-      await sleep(10);
+      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(10);
+      await sleep(20);
 
       expect(compC).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
         compute: 3,
@@ -285,7 +285,7 @@ describe('Async Signal functionality', () => {
         resolve: 0,
       });
 
-      await sleep(10);
+      await sleep(15);
 
       expect(compC).toHaveValueAndCounts(result(undefined, 'error', 'initial', 'error'), {
         compute: 2,
@@ -322,7 +322,7 @@ describe('Async Signal functionality', () => {
         resolve: 0,
       });
 
-      await sleep(30);
+      await sleep(40);
 
       expect(compC).toHaveValueAndCounts(result(undefined, 'error', 'initial', 'error'), {
         compute: 2,
@@ -368,7 +368,7 @@ describe('Async Signal functionality', () => {
       await sleep(30);
 
       expect(compD).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
-        compute: 3,
+        compute: 2,
         resolve: 1,
       });
     });

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();
+  });
 };

package/src/signals.ts

@@ -1,4 +1,5 @@
-import { scheduleDisconnect, scheduleWatcher } from './scheduling.js';
+import { scheduleDirty, scheduleDisconnect, schedulePull, scheduleWatcher } from './scheduling.js';
+import WeakRef from './weakref.js';
 
 let CURRENT_ORD = 0;
 let CURRENT_CONSUMER: ComputedSignal<any> | undefined;
@@ -125,7 +126,7 @@ export class ComputedSignal<T> {
 
               if (value.isPending) {
                 const currentConsumer = CURRENT_CONSUMER;
-                ACTIVE_ASYNCS.get(this)?.finally(() => currentConsumer._check());
+                ACTIVE_ASYNCS.get(this)?.finally(() => schedulePull(currentConsumer));
 
                 CURRENT_IS_WAITING = true;
                 throw WAITING;
@@ -305,7 +306,7 @@ export class ComputedSignal<T> {
                 value.isSuccess = true;
 
                 this._version++;
-                this._dirtyConsumers();
+                scheduleDirty(this);
               },
               error => {
                 if (currentVersion !== this._version || error === WAITING) {
@@ -316,7 +317,7 @@ export class ComputedSignal<T> {
                 value.isPending = false;
                 value.isError = true;
                 this._version++;
-                this._dirtyConsumers();
+                scheduleDirty(this);
               },
             );
 

package/src/weakref.ts

@@ -0,0 +1,9 @@
+class WeakRefPolyfill<T extends WeakKey> {
+  constructor(private value: T) {}
+
+  deref(): T {
+    return this.value;
+  }
+}
+
+export default typeof WeakRef === 'function' ? WeakRef : (WeakRefPolyfill as unknown as WeakRefConstructor);