@esportsplus/reactivity 0.31.3 → 0.32.0

package/build/system.js

@@ -1,20 +1,52 @@
-import { SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING } from './constants.js';
-import { isObject } from '@esportsplus/utilities';
-let depth = 0, heap = new Array(64), heap_i = 0, heap_n = 0, linkPoolHead = null, microtask = queueMicrotask, notified = false, observer = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0;
+import { PACKAGE_NAME, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING } from './constants.js';
+import { isObject, isPromise } from '@esportsplus/utilities';
+let asyncMeta = new WeakMap(), depth = 0, disposeHead = null, draining = false, heap = new Array(64), heap_i = 0, heap_n = 0, linkPoolHead = null, microtask = queueMicrotask, notified = false, observer = null, pendingHead = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0, walkPoolHead = null, writes = 0;
+function walkPop(walk) {
+    let prev = walk.prev;
+    walk.computed = null;
+    walk.link = null;
+    walk.prev = walkPoolHead;
+    walkPoolHead = walk;
+    return prev;
+}
+function walkPush(computed, link, prev) {
+    let walk = walkPoolHead;
+    if (walk !== null) {
+        walkPoolHead = walk.prev;
+        walk.computed = computed;
+        walk.link = link;
+        walk.prev = prev;
+        return walk;
+    }
+    return { computed, link, prev };
+}
 function cleanup(computed) {
     if (!computed.cleanup) {
         return;
     }
-    let value = computed.cleanup;
+    let errors = [], value = computed.cleanup;
+    computed.cleanup = null;
     if (typeof value === 'function') {
-        value();
+        try {
+            value();
+        }
+        catch (e) {
+            errors.push(e);
+        }
     }
     else {
         for (let i = 0, n = value.length; i < n; i++) {
-            value[i]();
+            try {
+                value[i]();
+            }
+            catch (e) {
+                errors.push(e);
+            }
         }
     }
-    computed.cleanup = null;
+    if (errors.length) {
+        throw errors.length === 1 ? errors[0] : new AggregateError(errors, `${PACKAGE_NAME}: cleanup produced multiple errors`);
+    }
 }
 function deleteFromHeap(computed) {
     let state = computed.state;
@@ -39,6 +71,18 @@ function deleteFromHeap(computed) {
     computed.nextHeap = undefined;
     computed.prevHeap = computed;
 }
+function drainPending() {
+    let node = pendingHead;
+    pendingHead = null;
+    while (node !== null) {
+        let next = node.nextPending === node ? null : node.nextPending;
+        node.nextPending = null;
+        for (let link = node.subs; link; link = link.nextSub) {
+            insertIntoHeap(link.sub);
+        }
+        node = next;
+    }
+}
 function insertIntoHeap(computed) {
     let state = computed.state;
     if (state & STATE_IN_HEAP) {
@@ -63,14 +107,19 @@ function insertIntoHeap(computed) {
     }
 }
 function link(dep, sub) {
+    if (dep.rv === version) {
+        return;
+    }
     let prevDep = sub.depsTail;
     if (prevDep && prevDep.dep === dep) {
+        dep.rv = version;
         return;
     }
     let nextDep = null;
     if (sub.state & STATE_RECOMPUTING) {
         nextDep = prevDep ? prevDep.nextDep : sub.deps;
         if (nextDep && nextDep.dep === dep) {
+            dep.rv = version;
             nextDep.version = version;
             sub.depsTail = nextDep;
             return;
@@ -80,8 +129,10 @@ function link(dep, sub) {
     if (prevSub &&
         prevSub.version === version &&
         prevSub.sub === sub) {
+        dep.rv = version;
         return;
     }
+    dep.rv = version;
     let pooled = linkPoolHead, newLink = sub.depsTail =
         dep.subsTail = pooled
             ? (linkPoolHead = pooled.nextDep,
@@ -119,9 +170,52 @@ function notify(computed, newState) {
         return;
     }
     computed.state = state | newState;
-    for (let link = computed.subs; link; link = link.nextSub) {
-        notify(link.sub, STATE_CHECK);
+    let link = computed.subs, stack = null;
+    for (;;) {
+        while (link !== null) {
+            let sub = link.sub, subState = sub.state;
+            if ((subState & STATE_NOTIFY_MASK) < STATE_CHECK) {
+                sub.state = subState | STATE_CHECK;
+                if (sub.subs !== null) {
+                    if (link.nextSub !== null) {
+                        stack = walkPush(null, link.nextSub, stack);
+                    }
+                    link = sub.subs;
+                    continue;
+                }
+            }
+            link = link.nextSub;
+        }
+        if (stack === null) {
+            break;
+        }
+        link = stack.link;
+        stack = walkPop(stack);
+    }
+}
+function pull(node) {
+    if (!notified) {
+        notified = true;
+        for (let i = 0; i <= heap_n; i++) {
+            for (let computed = heap[i]; computed !== undefined; computed = computed.nextHeap) {
+                notify(computed, STATE_DIRTY);
+            }
+        }
     }
+    let o = observer;
+    observer = null;
+    update(node);
+    observer = o;
+}
+function propagate(computed) {
+    for (let c = computed.subs; c; c = c.nextSub) {
+        let s = c.sub, state = s.state;
+        if (state & STATE_CHECK) {
+            s.state = state | STATE_DIRTY;
+        }
+        insertIntoHeap(s);
+    }
+    schedule();
 }
 function recompute(computed, del) {
     if (del) {
@@ -132,12 +226,19 @@ function recompute(computed, del) {
         computed.prevHeap = computed;
     }
     if (computed.cleanup) {
-        cleanup(computed);
+        try {
+            cleanup(computed);
+        }
+        catch (e) {
+            microtask(() => {
+                throw e;
+            });
+        }
     }
-    let o = observer, ok = true, value;
+    let err, flags = computed.state & STATE_EFFECT, hadError = computed.state & STATE_ERROR, o = observer, ok = true, value, w = writes;
     observer = computed;
     computed.depsTail = null;
-    computed.state = STATE_COMPUTED | STATE_RECOMPUTING;
+    computed.state = STATE_COMPUTED | STATE_RECOMPUTING | flags;
     depth++;
     version++;
     try {
@@ -145,10 +246,13 @@ function recompute(computed, del) {
     }
     catch (e) {
         ok = false;
+        err = e;
     }
     depth--;
+    version++;
     observer = o;
-    computed.state = STATE_COMPUTED;
+    computed.state = STATE_COMPUTED | flags;
+    computed.gv = w;
     let depsTail = computed.depsTail, remove = depsTail ? depsTail.nextDep : computed.deps;
     if (remove) {
         do {
@@ -161,16 +265,27 @@ function recompute(computed, del) {
             computed.deps = null;
         }
     }
-    if (ok && value !== computed.value) {
+    if (ok) {
+        computed.error = null;
+        let changed = computed.equals === null || computed.value === undefined
+            ? value !== computed.value
+            : !computed.equals(computed.value, value);
         computed.value = value;
-        for (let c = computed.subs; c; c = c.nextSub) {
-            let s = c.sub, state = s.state;
-            if (state & STATE_CHECK) {
-                s.state = state | STATE_DIRTY;
-            }
-            insertIntoHeap(s);
+        if (changed || hadError) {
+            propagate(computed);
+        }
+    }
+    else {
+        computed.error = err;
+        computed.state |= STATE_ERROR;
+        if (flags) {
+            microtask(() => {
+                throw err;
+            });
+        }
+        else {
+            propagate(computed);
         }
-        schedule();
     }
 }
 function schedule() {
@@ -190,6 +305,9 @@ function stabilize() {
     observer = null;
     stabilizer = STABILIZER_RUNNING;
     for (heap_i = 0; heap_i <= heap_n; heap_i++) {
+        if (pendingHead !== null) {
+            drainPending();
+        }
         let computed = heap[heap_i];
         heap[heap_i] = undefined;
         while (computed !== undefined) {
@@ -221,8 +339,17 @@ function unlink(link) {
     if (prevSub) {
         prevSub.nextSub = nextSub;
     }
-    else if ((dep.subs = nextSub) === null && dep.state & STATE_COMPUTED) {
-        dispose(dep);
+    else if ((dep.subs = nextSub) === null) {
+        if (dep.state & STATE_COMPUTED) {
+            dispose(dep);
+        }
+        else if (dep.parent !== undefined) {
+            let parent = dep.parent;
+            parent.keys.delete(dep.key);
+            if (parent.keys.size === 0) {
+                parent.keys = null;
+            }
+        }
     }
     link.dep = link.sub = null;
     link.nextSub = link.prevSub = null;
@@ -230,44 +357,123 @@ function unlink(link) {
     linkPoolHead = link;
     return nextDep;
 }
-function update(computed) {
-    if (computed.state & STATE_CHECK) {
-        for (let link = computed.deps; link; link = link.nextDep) {
-            let dep = link.dep;
-            if (dep.state & STATE_COMPUTED) {
-                update(dep);
-                if (computed.state & STATE_DIRTY) {
+function update(root) {
+    let link = null, node = root, resuming = false, stack = null, w = writes;
+    for (;;) {
+        if (!resuming) {
+            if (node.gv === w) {
+                node.state &= ~STATE_NOTIFY_MASK;
+            }
+            else if (node.state & STATE_CHECK) {
+                link = node.deps;
+                resuming = true;
+            }
+            else if (node.state & STATE_DIRTY) {
+                recompute(node, true);
+                node.state &= ~STATE_NOTIFY_MASK;
+            }
+            else {
+                node.gv = w;
+                node.state &= ~STATE_NOTIFY_MASK;
+            }
+        }
+        if (resuming) {
+            let descended = false;
+            while (link !== null && !(node.state & STATE_DIRTY)) {
+                if (link.dep.state & STATE_COMPUTED) {
+                    stack = walkPush(node, link.nextDep, stack);
+                    node = link.dep;
+                    link = null;
+                    resuming = false;
+                    descended = true;
                     break;
                 }
+                link = link.nextDep;
+            }
+            if (descended) {
+                continue;
             }
+            if (node.state & STATE_DIRTY) {
+                recompute(node, true);
+            }
+            else {
+                node.gv = w;
+            }
+            node.state &= ~STATE_NOTIFY_MASK;
+            resuming = false;
         }
+        if (stack === null) {
+            return;
+        }
+        node = stack.computed;
+        link = stack.link;
+        stack = walkPop(stack);
+        resuming = true;
     }
-    if (computed.state & STATE_DIRTY) {
-        recompute(computed, true);
-    }
-    computed.state = STATE_COMPUTED;
 }
-const asyncComputed = (fn) => {
-    let factory = computed(fn), node = signal(undefined), v = 0;
-    onCleanup(effect(() => {
-        let id = ++v;
-        read(factory).then((value) => {
-            if (id === v) {
-                write(node, value);
+function makeAsyncComputed(factory) {
+    let error = signal(undefined), node = signal(undefined), v = 0;
+    let stop = effect(() => {
+        let fail = (e) => {
+            if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+                write(error, e === undefined ? new Error('reactivity: async computed rejected with undefined') : e);
             }
-        }, () => { });
-    }));
-    return node;
-};
-const computed = (fn) => {
+        }, id = ++v, result = read(factory);
+        if (isPromise(result)) {
+            result.then((value) => {
+                if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+                    write(error, undefined);
+                    write(node, value);
+                }
+            }, fail);
+        }
+        else if (result != null && typeof result[Symbol.asyncIterator] === 'function') {
+            let it = result[Symbol.asyncIterator]();
+            onCleanup(() => {
+                it.return?.();
+            });
+            let step = (r) => {
+                if (id !== v || (factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+                    return;
+                }
+                if (!r.done) {
+                    write(error, undefined);
+                    write(node, r.value);
+                    it.next().then(step, fail);
+                }
+            };
+            untrack(() => it.next()).then(step, fail);
+        }
+        else {
+            write(error, undefined);
+            write(node, result);
+        }
+    });
+    let wrapper = makeComputed(() => {
+        let e = read(error);
+        if (e !== undefined) {
+            throw e;
+        }
+        return read(node);
+    });
+    asyncMeta.set(wrapper, { factory: factory });
+    wrapper.disposal = stop;
+    return wrapper;
+}
+function makeComputed(fn, eager = false) {
     let self = {
         cleanup: null,
         deps: null,
         depsTail: null,
+        disposal: null,
+        equals: null,
+        error: null,
         fn: fn,
+        gv: 0,
         height: 0,
         nextHeap: undefined,
         prevHeap: null,
+        rv: 0,
         state: STATE_COMPUTED,
         subs: null,
         subsTail: null,
@@ -279,6 +485,10 @@ const computed = (fn) => {
             self.height = observer.height;
             recompute(self, false);
         }
+        else if (eager) {
+            self.height = observer.height + 1;
+            recompute(self, false);
+        }
         else {
             self.height = observer.height + 1;
             insertIntoHeap(self);
@@ -295,24 +505,102 @@ const computed = (fn) => {
         }
     }
     return self;
+}
+const batch = (fn) => {
+    depth++;
+    try {
+        return fn();
+    }
+    finally {
+        depth--;
+        if (!depth) {
+            schedule();
+        }
+    }
+};
+const computed = (fn, equals = null) => {
+    let o = observer, self = makeComputed(fn, true), value = self.value;
+    if (isPromise(value) || (value != null && typeof value[Symbol.asyncIterator] === 'function')) {
+        self = untrack(() => makeAsyncComputed(self));
+        if (o) {
+            onCleanup(() => dispose(self));
+        }
+    }
+    self.equals = equals;
+    return self;
+};
+computed.invalidate = (c) => {
+    let meta = asyncMeta.get(c);
+    if (meta) {
+        computed.invalidate(meta.factory);
+        return;
+    }
+    writes++;
+    c.state |= STATE_DIRTY;
+    insertIntoHeap(c);
+    schedule();
 };
 const dispose = (computed) => {
-    deleteFromHeap(computed);
-    let dep = computed.deps;
-    while (dep) {
-        dep = unlink(dep);
+    if (draining) {
+        disposeHead = walkPush(computed, null, disposeHead);
+        return;
     }
-    computed.deps = null;
-    if (computed.cleanup) {
-        cleanup(computed);
+    draining = true;
+    let node = computed;
+    try {
+        for (;;) {
+            deleteFromHeap(node);
+            let dep = node.deps;
+            while (dep) {
+                dep = unlink(dep);
+            }
+            node.deps = null;
+            if (node.cleanup) {
+                cleanup(node);
+            }
+            if (node.disposal) {
+                let d = node.disposal;
+                node.disposal = null;
+                d();
+            }
+            if (disposeHead === null) {
+                break;
+            }
+            node = disposeHead.computed;
+            disposeHead = walkPop(disposeHead);
+        }
+    }
+    finally {
+        draining = false;
     }
 };
-const effect = (fn) => {
-    let c = computed(fn);
+const effect = (fn, onError) => {
+    let c = makeComputed(onError
+        ? (o) => {
+            try {
+                return fn(o);
+            }
+            catch (e) {
+                onError(e);
+            }
+        }
+        : fn);
+    c.state |= STATE_EFFECT;
+    if (c.state & STATE_ERROR) {
+        let err = c.error;
+        microtask(() => {
+            throw err;
+        });
+    }
     return () => {
         dispose(c);
     };
 };
+const flush = () => {
+    while (stabilizer === STABILIZER_SCHEDULED) {
+        stabilize();
+    }
+};
 const isComputed = (value) => {
     return isObject(value) && !!(value.state & STATE_COMPUTED);
 };
@@ -336,27 +624,37 @@ const onCleanup = (fn) => {
     }
     return fn;
 };
+const peek = (node) => {
+    if (node.state & STATE_COMPUTED) {
+        if (pendingHead !== null) {
+            drainPending();
+        }
+        pull(node);
+    }
+    if (node.state & STATE_ERROR) {
+        throw node.error;
+    }
+    return node.value;
+};
 const read = (node) => {
     if (observer) {
         link(node, observer);
         if (node.state & STATE_COMPUTED) {
+            if (pendingHead !== null) {
+                drainPending();
+            }
             let height = node.height;
             if (height >= observer.height) {
                 observer.height = height + 1;
             }
             if (height >= heap_i || node.state & STATE_NOTIFY_MASK) {
-                if (!notified) {
-                    notified = true;
-                    for (let i = 0; i <= heap_n; i++) {
-                        for (let computed = heap[i]; computed !== undefined; computed = computed.nextHeap) {
-                            notify(computed, STATE_DIRTY);
-                        }
-                    }
-                }
-                update(node);
+                pull(node);
             }
         }
     }
+    if (node.state & STATE_ERROR) {
+        throw node.error;
+    }
     return node.value;
 };
 const root = (fn) => {
@@ -380,26 +678,74 @@ const root = (fn) => {
     return value;
 };
 root.disposables = 0;
-const signal = (value) => {
+const signal = (value, equals = null) => {
     return {
+        equals: equals,
+        keys: null,
+        nextPending: null,
+        rv: 0,
         subs: null,
         subsTail: null,
         type: SIGNAL,
         value,
     };
 };
+signal.selector = (node, key) => {
+    if (!observer) {
+        return node.value === key;
+    }
+    let keys = (node.keys ??= new Map()), entry = keys.get(key);
+    if (entry === undefined) {
+        keys.set(key, entry = {
+            equals: null,
+            key,
+            keys: null,
+            nextPending: null,
+            parent: node,
+            rv: 0,
+            subs: null,
+            subsTail: null,
+            type: SIGNAL,
+            value: node.value === key
+        });
+    }
+    return read(entry);
+};
+const untrack = (fn) => {
+    let o = observer;
+    observer = null;
+    try {
+        return fn();
+    }
+    finally {
+        observer = o;
+    }
+};
 const write = (signal, value) => {
-    if (signal.value === value) {
+    let prev = signal.value;
+    if (signal.equals === null ? prev === value : signal.equals(prev, value)) {
         return;
     }
     signal.value = value;
+    writes++;
+    if (signal.keys !== null) {
+        let entry = signal.keys.get(prev);
+        if (entry !== undefined) {
+            write(entry, false);
+        }
+        entry = signal.keys.get(value);
+        if (entry !== undefined) {
+            write(entry, true);
+        }
+    }
     if (signal.subs === null) {
         return;
     }
     notified = false;
-    for (let link = signal.subs; link; link = link.nextSub) {
-        insertIntoHeap(link.sub);
+    if (signal.nextPending === null) {
+        signal.nextPending = pendingHead ?? signal;
+        pendingHead = signal;
     }
     schedule();
 };
-export { asyncComputed, computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, write };
+export { batch, computed, dispose, effect, flush, isComputed, isSignal, onCleanup, peek, read, root, signal, untrack, write };

package/build/types.d.ts

@@ -5,10 +5,15 @@ interface Computed<T> {
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
     depsTail: Link | null;
+    disposal: VoidFunction | null;
+    equals: ((a: unknown, b: unknown) => boolean) | null;
+    error: unknown;
     fn: (onCleanup: (fn: VoidFunction) => typeof fn) => T;
+    gv: number;
     height: number;
     nextHeap: Computed<unknown> | undefined;
     prevHeap: Computed<unknown>;
+    rv: number;
     state: number;
     subs: Link | null;
     subsTail: Link | null;
@@ -23,16 +28,23 @@ interface Link {
     version: number;
 }
 declare const READONLY: unique symbol;
-type Reactive<T> = T extends (...args: unknown[]) => Promise<infer R> ? (R | undefined) & {
-    readonly [READONLY]: true;
-} : T extends (...args: any[]) => infer R ? R & {
+type Reactive<T> = T extends (...args: never[]) => infer R ? Settled<R> & {
     readonly [READONLY]: true;
 } : T extends (infer U)[] ? U[] & Pick<ReactiveArray<U>, 'clear' | 'dispose' | 'on' | 'once'> : T extends Record<PropertyKey, unknown> ? {
     [K in keyof T]: T[K] extends (infer U)[] ? Reactive<U[]> : T[K];
 } & {
     dispose: VoidFunction;
 } : T;
+type SelectorSignal<T> = Signal<boolean> & {
+    key: T;
+    parent: Signal<T>;
+};
+type Settled<T> = T extends Promise<infer U> ? Awaited<U> | undefined : T extends AsyncIterable<infer U> ? U | undefined : T;
 type Signal<T> = {
+    equals: ((a: unknown, b: unknown) => boolean) | null;
+    keys: Map<T, SelectorSignal<T>> | null;
+    nextPending: Signal<unknown> | null;
+    rv: number;
     subs: Link | null;
     subsTail: Link | null;
     type: typeof SIGNAL;
@@ -43,4 +55,4 @@ interface TransformResult {
     code: string;
     sourceFile: ts.SourceFile;
 }
-export type { Computed, Link, Reactive, Signal, TransformResult };
+export type { Computed, Link, Reactive, SelectorSignal, Settled, Signal, TransformResult };