signalium 0.2.2 → 0.2.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # signalium
 
+## 0.2.4
+
+### Patch Changes
+
+- c2af4d0: Refactor scheduling, add batching for React Native
+
+## 0.2.3
+
+### Patch Changes
+
+- 0ba50a0: Remove linked-lists for deps and subs
+
 ## 0.2.2
 
 ### 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.d.ts

@@ -32,26 +32,22 @@ declare const enum SignalState {
     Dirty = 2
 }
 interface Link {
-    id: number;
-    sub: WeakRef<ComputedSignal<any>>;
     dep: ComputedSignal<any>;
+    sub: WeakRef<ComputedSignal<any>>;
     ord: number;
     version: number;
-    nextDep: Link | undefined;
-    nextSub: Link | undefined;
-    prevSub: Link | undefined;
+    consumedAt: number;
     nextDirty: Link | undefined;
 }
-export declare function endTrack(sub: ComputedSignal<any>, shouldDisconnect: boolean): void;
 export declare class ComputedSignal<T> {
-    id: number;
+    _id: number;
     _type: SignalType;
-    _subs: Link | undefined;
-    _subsTail: Link | undefined;
-    _deps: Link | undefined;
+    _deps: Map<ComputedSignal<any>, Link>;
     _dirtyDep: Link | undefined;
+    _subs: Set<Link>;
     _state: SignalState;
     _version: number;
+    _computedCount: number;
     _connectedCount: number;
     _currentValue: T | AsyncResult<T> | undefined;
     _compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T> | undefined;
@@ -60,7 +56,7 @@ export declare class ComputedSignal<T> {
     constructor(type: SignalType, compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T> | undefined, equals?: SignalEquals<T>, initValue?: T);
     get(): T | AsyncResult<T>;
     _check(shouldWatch?: boolean): number;
-    _run(wasConnected: boolean, isConnected: boolean, shouldConnect: boolean): void;
+    _run(wasConnected: boolean, shouldConnect: boolean): void;
     _resetDirty(): void;
     _dirty(): void;
     _dirtyConsumers(): void;
@@ -92,7 +88,7 @@ export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;
 declare class StateSignal<T> implements StateSignal<T> {
     private _value;
     private _equals;
-    private _consumers;
+    private _subs;
     constructor(_value: T, _equals?: SignalEquals<T>);
     get(): T;
     set(value: T): void;