@solidjs/signals 2.0.0-rc.17 → 2.0.0-rc.19

package/dist/observe/from.js

@@ -0,0 +1,248 @@
+import { isThenable, onSupersede } from "./core/async.js";
+
+import { CONFIG_CHILDREN_FORBIDDEN } from "./core/constants.js";
+
+import { cleanup, getOwner } from "./core/owner.js";
+
+// `from` — a push source (callback subscription, Observable, AsyncIterable)
+// as an AsyncIterable a computation can return or `for await` over:
+//   const value = createMemo(() => from(source));
+// A subscription keeps the latest value: values that arrive between pulls
+// coalesce. An AsyncIterable streams through unchanged. Either way the source
+// opens when the result is iterated and closes on return(), on supersede (the
+// owning computation re-runs) and on owner disposal, whichever comes first.
+function toSubscribe(e) {
+    if (typeof e === "function") return e;
+    // TC39 / RxJS interop: `Symbol.observable` (or "@@observable") returns the observable.
+    // Read per call, not at module scope, so the module stays side-effect free.
+        const n = Symbol.observable;
+    const r = (n && e?.[n]) ?? e?.["@@observable"];
+    const t = typeof r === "function" ? r.call(e) : e;
+    if (t && typeof t.subscribe === "function") return (e, n, r) => t.subscribe({
+        next: e,
+        error: n,
+        complete: r
+    });
+    return null;
+}
+
+const DONE = {
+    value: undefined,
+    done: true
+};
+
+/**
+ * Ties an iterator's `finish` to the computation iterating it. Solid reaches
+ * an iterator's return() only when the compute returns the iterable directly.
+ * Inside an async generator the generator's own return() is queued behind its
+ * pending `await`, and owner cleanups wait for the replacing pass to commit,
+ * so close on supersede, with owner disposal as the backstop. No owner (an
+ * async compute iterating it after its first `await`, or plain iteration):
+ * no registration and no diagnostic, so only return() closes it. Scopes that
+ * forbid cleanups rely on supersede and return().
+ */ function bindToOwner(e) {
+    const n = getOwner();
+    if (!n) return;
+    onSupersede(e);
+    if (!(n.l & CONFIG_CHILDREN_FORBIDDEN)) cleanup(e);
+}
+
+/**
+ * An AsyncIterable as a stream bound to the iterating computation: every
+ * value passes through (no coalescing). `finish` calls the inner return()
+ * once and settles pending pulls as done, so a `for await` over it exits as
+ * soon as the computation re-runs — even when the inner iterator is an async
+ * generator whose own return() the language queues behind its pending
+ * `await`.
+ */ function wrapIterable(e) {
+    return {
+        [Symbol.asyncIterator]() {
+            const n = e[Symbol.asyncIterator]();
+            let r = false;
+            const t = new Set;
+            const finish = () => {
+                if (r) return DONE;
+                r = true;
+                for (const e of t) e(DONE);
+                t.clear();
+                try {
+                    const e = n.return?.();
+                    if (isThenable(e)) e.then(undefined, () => {});
+                } catch {}
+                return DONE;
+            };
+            bindToOwner(finish);
+            return {
+                next(...e) {
+                    if (r) return Promise.resolve(DONE);
+                    const o = n.next(...e);
+                    // A bare result (the producer's buffered fast path) passes through.
+                                        if (!isThenable(o)) return o;
+                    return new Promise((e, n) => {
+                        t.add(e);
+                        o.then(n => t.delete(e) && e(n), r => t.delete(e) && n(r));
+                    });
+                },
+                return() {
+                    return Promise.resolve(finish());
+                }
+            };
+        }
+    };
+}
+
+const toCleanup = e => typeof e === "function" ? e : e && typeof e.unsubscribe === "function" ? () => e.unsubscribe() : () => {};
+
+/**
+ * Converts a callback subscription, an Observable or an AsyncIterable into an
+ * AsyncIterable for a Solid computation. A subscription keeps only the latest
+ * value, and a value the source emits during `subscribe` is served without a
+ * loading frame; an AsyncIterable streams every value through.
+ *
+ * The source closes on supersede — the owning computation re-running — and
+ * on owner disposal. Inside an async generator memo that holds for a
+ * `for await` that starts before the first `await`; one that starts after it
+ * has no owner to bind to, so its source closes only when the loop ends.
+ * Prefer returning `from(...)` from its own memo, with awaited inputs read
+ * from upstream memos and transforms done in a downstream memo.
+ *
+ * Iterate the result with `for await` or return it from a computation: its
+ * `next()` returns an already-buffered value as a bare result, not a promise.
+ *
+ * @example
+ * ```ts
+ * const position = createMemo(() =>
+ *   from<Position>((next, error) => {
+ *     const id = navigator.geolocation.watchPosition(next, error);
+ *     return () => navigator.geolocation.clearWatch(id);
+ *   })
+ * );
+ * const ticks = createMemo(() => from(interval$(rate())));
+ * ```
+ */ function from(e) {
+    const n = toSubscribe(e);
+    if (!n) {
+        if (e && typeof e[Symbol.asyncIterator] === "function") return wrapIterable(e);
+        throw new TypeError("from(): expected a subscribe function, an Observable or an AsyncIterable");
+    }
+    return {
+        [Symbol.asyncIterator]() {
+            let e;
+            let r = false;
+            let t = false;
+            let o = false;
+            let u;
+            let f = null;
+            let l = null;
+            let s = false;
+            const close = () => {
+                if (s) return;
+                s = true;
+                t = true;
+                const e = l;
+                l = null;
+                // A throwing unsubscribe must not escape: at supersede this runs
+                // inside flush(), ahead of the replacing pass (the returned-iterator
+                // path swallows it the same way).
+                                try {
+                    e?.();
+                } catch {}
+            };
+            const settle = () => {
+                if (!f) return;
+                const n = f;
+                if (r) {
+                    f = null;
+                    r = false;
+                    n.resolve({
+                        value: e,
+                        done: false
+                    });
+                } else if (o) {
+                    f = null;
+                    o = false;
+                    n.reject(u);
+                } else if (t) {
+                    f = null;
+                    n.resolve({
+                        value: undefined,
+                        done: true
+                    });
+                }
+            };
+            const i = n(n => {
+                if (t) return;
+                e = n;
+                r = true;
+                settle();
+            }, e => {
+                if (t) return;
+                o = true;
+                u = e;
+                t = true;
+                settle();
+                close();
+            }, () => {
+                if (t) return;
+                t = true;
+                settle();
+                close();
+            });
+            l = toCleanup(i);
+            // Completed or errored during subscribe: release what it just returned.
+                        if (s) {
+                const e = l;
+                l = null;
+                try {
+                    e();
+                } catch {}
+            }
+            // Idempotent: return(), supersede and disposal may all reach it.
+                        const finish = () => {
+                close();
+                r = false;
+                if (f) {
+                    const e = f;
+                    f = null;
+                    e.resolve(DONE);
+                }
+                return DONE;
+            };
+            bindToOwner(finish);
+            return {
+                next() {
+                    // A buffered value is returned as a bare result, not a promise: the
+                    // iterator consumer lands it in the same pass, so a source that
+                    // emits during subscribe (BehaviorSubject-style) shows its value
+                    // with no loading frame. `for await` accepts either form.
+                    if (r) {
+                        r = false;
+                        return {
+                            value: e,
+                            done: false
+                        };
+                    }
+                    if (o) {
+                        o = false;
+                        return Promise.reject(u);
+                    }
+                    if (t) return Promise.resolve({
+                        value: undefined,
+                        done: true
+                    });
+                    return new Promise((e, n) => {
+                        f = {
+                            resolve: e,
+                            reject: n
+                        };
+                    });
+                },
+                return() {
+                    return Promise.resolve(finish());
+                }
+            };
+        }
+    };
+}
+
+export { from };

package/dist/observe/index.js

@@ -20,7 +20,7 @@ import { OBSERVE as OBSERVE$1 } from "./core/dev.js";
 
 export { setConsoleFooter } from "./core/dev.js";
 
-export { ROOT_ERROR_HOOK, enforceLoadingBoundary, flush, resetErrorHalt } from "./core/scheduler.js";
+export { ROOT_ERROR_HOOK, clock, enforceLoadingBoundary, flush, resetErrorHalt } from "./core/scheduler.js";
 
 import "./core/effect.js";
 
@@ -28,7 +28,7 @@ export { configureClientErrors } from "./core/error-hooks.js";
 
 export { storeName } from "./store/edges.js";
 
-export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, refresh, resolve, until } from "./signals.js";
+export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onFlush, onSettled, refresh, resolve, until } from "./signals.js";
 
 export { mapArray, repeat } from "./map.js";
 
@@ -38,6 +38,8 @@ export { affects } from "./affects.js";
 
 export { createDeferred } from "./deferred.js";
 
+export { from } from "./from.js";
+
 export { flatten } from "./flatten.js";
 
 export { createErrorBoundary, createLoadingBoundary } from "./boundaries.js";

package/dist/observe/map.js

@@ -29,7 +29,7 @@ function mapArray(t, e, i) {
         Mt: [],
         Wt: r,
         vt: [],
-        je: [],
+        Ye: [],
         Vt: s,
         Kt: s || i?.keyed === false ? [] : undefined,
         xt: n && i?.keyed !== false ? [] : undefined,
@@ -157,7 +157,7 @@ function trySmallMove(t, e, i, s) {
         }
     }
     const a = t.vt;
-    const l = t.je;
+    const l = t.Ye;
     const u = a.slice(0, i);
     const d = l.slice(0, i);
     for (let t = 0; t < r.length; t += 3) {
@@ -177,7 +177,7 @@ function trySmallMove(t, e, i, s) {
         d[t] = l[e];
     }
     t.vt = u;
-    t.je = d;
+    t.Ye = d;
     t.wt = i;
     t.Mt = e.slice(0);
     // Dispose unmatched sources LAST (general-path ordering).
@@ -197,7 +197,7 @@ function trySmallMove(t, e, i, s) {
  * needs the reset). The stage arrays are scratch — nothing live is touched. */ function stageRemoval(t, e, i, s, n, r, o, f, h) {
     const c = t.Vt;
     const a = t.Mt;
-    const l = t.je;
+    const l = t.Ye;
     const u = [];
     let d = i;
     for (let p = i; p <= n; d++, p++) {
@@ -222,7 +222,7 @@ function trySmallMove(t, e, i, s) {
  * index signals. Its own function so the general path's body stays under
  * the JIT's optimization budget — the inlined commit measured ~10% slower on
  * full-window reorders (the small-move note has the same finding). */ function commitWindow(t, e, i, s, n, r, o, f, h) {
-    const c = t.je;
+    const c = t.Ye;
     const a = t.Kt;
     const l = t.xt;
     const u = t.wt;
@@ -267,7 +267,7 @@ function updateKeyedMap() {
     // the flight's reader (pending tracking + post-settle retry) instead of
     // vanishing. Set per pass: the first pass runs inside `computed()`, before
     // the node exists to the caller.
-    this.H.Ht = getOwner();
+    this.H.ht = getOwner();
     const t = this.yt() || [], e = t.length;
     t[$TRACK];
  // top level tracking (a store array's container node)
@@ -298,7 +298,7 @@ function updateKeyedMap() {
                 if (e === 0) {
             if (this.wt !== 0) {
                 this.H.dispose(false);
-                this.je = [];
+                this.Ye = [];
                 this.Mt = [];
                 this.vt = [];
                 this.wt = 0;
@@ -308,8 +308,8 @@ function updateKeyedMap() {
             if (this.L && !this.vt.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.je[0]?.dispose();
-                this.vt[0] = runWithOwner(this.je[0] = createOwner(), this.L);
+                this.Ye[0]?.dispose();
+                this.vt[0] = runWithOwner(this.Ye[0] = createOwner(), this.L);
             }
         }
         // fast path for new create
@@ -328,10 +328,10 @@ function updateKeyedMap() {
                 throw t;
             }
             // commit
-                        if (this.je[0]) this.je[0].dispose();
+                        if (this.Ye[0]) this.Ye[0].dispose();
  // previous fallback
                         this.vt = h;
-            this.je = c;
+            this.Ye = c;
             r && (this.Kt = r);
             o && (this.xt = o);
             this.Mt = t.slice(0);
@@ -447,13 +447,13 @@ function updateKeyedMap() {
                     s = d.get(u);
                     if (s !== undefined && s !== -1) {
                         S[s] = this.vt[i];
-                        M[s - h] = this.je[i];
+                        M[s - h] = this.Ye[i];
                         r && (r[s - h] = this.Kt[i]);
                         o && (o[s - h] = this.xt[i]);
                         s = p[s - h];
                         d.set(u, s);
                     } else {
-                        (w ??= []).push(this.je[i]);
+                        (w ??= []).push(this.Ye[i]);
                         if (true && attrHooks !== null) (O ??= []).push(l);
                     }
                 }
@@ -483,7 +483,7 @@ function updateKeyedMap() {
             // save a copy of the mapped items for the next update
                         this.Mt = t.slice(0);
             if (w) for (i = 0; i < w.length; i++) w[i].dispose();
-            if (true && attrHooks !== null && O !== undefined && _ !== undefined) attrHooks.listChurn(this.H.Ht, O, _, e, this.Vt !== undefined);
+            if (true && attrHooks !== null && O !== undefined && _ !== undefined) attrHooks.listChurn(this.H.ht, O, _, e, this.Vt !== undefined);
         }
     });
     return this.vt;
@@ -511,7 +511,7 @@ function updateKeyedMap() {
         $t: 0,
         qt: t,
         Wt: s,
-        je: [],
+        Ye: [],
         vt: [],
         zt: i?.from,
         L: i?.fallback
@@ -530,14 +530,14 @@ function updateKeyedMap() {
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
     // As in updateKeyedMap: the node is the row callbacks' reader, per pass.
-    this.H.Ht = getOwner();
+    this.H.ht = getOwner();
     const t = this.qt();
     const e = this.zt?.() || 0;
     runWithOwner(this.H, () => {
         if (t === 0) {
             if (this.wt !== 0) {
                 this.H.dispose(false);
-                this.je = [];
+                this.Ye = [];
                 this.vt = [];
                 this.wt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
@@ -546,8 +546,8 @@ function updateRepeat() {
             if (this.L && !this.vt.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.je[0]?.dispose();
-                this.vt[0] = runWithOwner(this.je[0] = createOwner(), this.L);
+                this.Ye[0]?.dispose();
+                this.vt[0] = runWithOwner(this.Ye[0] = createOwner(), this.L);
             }
             return;
         }
@@ -560,7 +560,7 @@ function updateRepeat() {
         const o = new Array(t);
         const f = new Array(t);
         for (let t = n; t < r; t++) {
-            f[t - e] = this.je[t - this.$t];
+            f[t - e] = this.Ye[t - this.$t];
             o[t - e] = this.vt[t - this.$t];
         }
         try {
@@ -573,9 +573,9 @@ function updateRepeat() {
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.wt === 0) this.je[0]?.dispose(); else for (let t = this.$t; t < s; t++) if (t < e || t >= i) this.je[t - this.$t].dispose();
+                if (this.wt === 0) this.Ye[0]?.dispose(); else for (let t = this.$t; t < s; t++) if (t < e || t >= i) this.Ye[t - this.$t].dispose();
         this.vt = o;
-        this.je = f;
+        this.Ye = f;
         this.$t = e;
         this.wt = t;
     });

package/dist/observe/reveal.js

@@ -106,7 +106,7 @@ class RevealController {
         }
         return t !== "natural";
     }
-    oe(t) {
+    te(t) {
         if (this.Zt.includes(t)) return;
         this.Zt.push(t);
         // Gated from the start (collapsed in a collapsed sequential tail); the
@@ -124,7 +124,7 @@ class RevealController {
         }
         untrack(() => this.Bt());
     }
-    te(t) {
+    oe(t) {
         const e = this.Zt.indexOf(t);
         if (e >= 0) this.Zt.splice(e, 1);
         untrack(() => this.Bt());
@@ -194,8 +194,8 @@ class RevealController {
         });
         if (true) s._name = "reveal order";
         if (r) {
-            r.oe(i);
-            cleanup(() => r.te(i));
+            r.te(i);
+            cleanup(() => r.oe(i));
         }
         return e;
     });
@@ -204,8 +204,8 @@ class RevealController {
 // Installed at module evaluation — present exactly when something imports
 // `createRevealOrder`; a Loading boundary without one pays a null check.
 setRevealHooks({
-    oe: (t, e) => t.oe(e),
     te: (t, e) => t.te(e),
+    oe: (t, e) => t.oe(e),
     P: t => t.Bt()
 });
 

package/dist/observe/signals.js

@@ -8,7 +8,7 @@ import { computed, signal, runWithOwner, setMemo, setSignal, markRefresh, read,
 
 import { registerGraph } from "./core/dev.js";
 
-import { globalQueue, flushTransaction, dirtyQueue, GlobalQueue, resolveTx, passTx, staleReader, joinFuture } from "./core/scheduler.js";
+import { schedule, globalQueue, flushTransaction, dirtyQueue, GlobalQueue, resolveTx, passTx, staleReader, joinFuture } from "./core/scheduler.js";
 
 import { cleanup, createRoot, getOwner, dispose } from "./core/owner.js";
 
@@ -343,14 +343,14 @@ function createMemo(e, t) {
     // or an already-displayed guess would satisfy it in a later slice. (REDERIVE
     // after: the first pass's own error is the promise's rejection.)
         computed(() => {
-        let i, u = false;
+        let u, i = false;
         try {
-            i = e();
+            u = e();
         } catch (e) {
             if (e instanceof NotReadyError) throw e;
             // An error is an answer (D-41): delivered by the same frame rule.
-                        i = unwrapStatusError(e);
-            u = true;
+                        u = unwrapStatusError(e);
+            i = true;
         }
         const s = getOwner();
         // A truth reader waits out a `createDeferred` flight its value derives
@@ -363,9 +363,9 @@ function createMemo(e, t) {
             staleReader(s, resolveTx(a));
             return;
         }
-        if (u) return void queueMicrotask(() => r(i));
-        o?.(i);
-        queueMicrotask(() => t(i));
+        if (i) return void queueMicrotask(() => r(u));
+        o?.(u);
+        queueMicrotask(() => t(u));
     }, {
         St: n
     }).l |= CONFIG_REDERIVE;
@@ -525,14 +525,14 @@ function createMemo(e, t) {
         // (`saving=true` beside the confirmed `version=1` is a tear no timeline
         // contains). Updates that do not flip the predicate reveal freely.
                 const c = flushTransaction;
-        createRoot(i => {
-            let u;
+        createRoot(u => {
+            let i;
             let s;
             const settle = e => {
-                if (u !== undefined) clearTimeout(u);
+                if (i !== undefined) clearTimeout(i);
                 if (s !== undefined) o.removeEventListener("abort", s);
                 e();
-                i();
+                u();
             };
             // Authoritative: the predicate sees the truth, never the action's own
             // optimistic guess — a guess cannot satisfy the wait for its own
@@ -547,7 +547,7 @@ function createMemo(e, t) {
                 // revealed with the action.
                 if (e && c !== null && globalQueue.q && resolveTx(c).tt !== 0) joinFuture(c);
             });
-            if (t?.timeout !== undefined) u = setTimeout(() => settle(() => n(new TimeoutError)), t.timeout);
+            if (t?.timeout !== undefined) i = setTimeout(() => settle(() => n(new TimeoutError)), t.timeout);
             if (o !== undefined) {
                 s = () => settle(() => n(o.reason));
                 o.addEventListener("abort", s, {
@@ -663,7 +663,7 @@ function createMemo(e, t) {
         // still holding the optimistic value — reads do not pull (#3411). Fall
         // to the next pass while the heap has work; `run` swapped the queue,
         // so this lands there, and `enqueue` keeps the drain alive.
-        if (dirtyQueue.jt >= dirtyQueue.st) return globalQueue.enqueue(EFFECT_USER, fire);
+        if (dirtyQueue.jt >= dirtyQueue.lt) return globalQueue.enqueue(EFFECT_USER, fire);
         // Unowned, out-of-band fire (no owner, or a children-forbidden one this
         // one-shot must not bind to): a returned cleanup has no lifecycle to
         // attach to. Reject it in dev; in production the return is simply
@@ -672,4 +672,46 @@ function createMemo(e, t) {
     });
 }
 
-export { accessor, createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, refresh, resolve, until };
+/**
+ * Schedules `callback` to run **once**, right after the pending flush
+ * finishes, in the same microtask checkpoint (before the browser paints).
+ * Unlike `onSettled`, it never waits on async work: if that flush is held by
+ * a pending transition, the callback still runs.
+ *
+ * Its main use is keeping a write out of another update's hold. Writes made
+ * in the same synchronous frame are applied together, so when one of them
+ * starts async work (a route change, a fetch), the others are held with it
+ * until it resolves. A write made in `onFlush` happens after that flush, so
+ * it is its own update: it commits on its own unless something it changes
+ * also derives from the held work (a memo or `createEffect` reading both),
+ * in which case it joins that hold as any later write would.
+ *
+ * Call it from event handlers and effect callbacks (including
+ * `createTrackedEffect` and `onSettled` bodies). In an owned scope such as a
+ * component body or a computation it warns in dev: use `onSettled` there.
+ *
+ * - A write in the callback lands after any write made inline in the same
+ *   frame. Don't write the same signal both inside and outside it; use a
+ *   functional setter if the order matters.
+ * - Several `onFlush` callbacks run in call order and batch into one flush.
+ * - `queueMicrotask` is not a substitute: called before the frame's first
+ *   write, it runs before that flush and its write joins it.
+ *
+ * @example
+ * ```tsx
+ * // A menu closes now even when the consumer's onSelect starts async work.
+ * const select = (id: string) => {
+ *   onFlush(() => setOpen(false));
+ *   props.onSelect?.(id);
+ * };
+ * ```
+ *
+ * @param callback Function to run once after the pending flush
+ */ function onFlush(e) {
+    // The frame's flush is queued (or already draining) ahead of this
+    // microtask, so the callback's writes start a flush of their own.
+    schedule();
+    queueMicrotask(e);
+}
+
+export { accessor, createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onFlush, onSettled, refresh, resolve, until };

package/dist/observe/store/affects.js

@@ -72,7 +72,7 @@ function scopeOf(e, o) {
     if (f !== undefined) {
         if (f.pb !== null) o.oo.add(f.v);
         // The writer's view: the tick's own unflushed guesses are in motion too.
-                if (f.fam?.opt === true) r = optHooks.view(f, r, true);
+                if (optHooks && f.fam?.opt === true) r = optHooks.view(f, r, true);
         const e = f.n;
         if (e !== null) for (const o of Reflect.ownKeys(e)) 
         // Another mark's carrier is its own channel: counting it here would

package/dist/observe/store/hooks.js

@@ -1,3 +1,6 @@
+// Set before any family is optimistic (`fam.opt`): a call site checks the
+// hooks first, so a build that does not import optimistic.ts folds the arm
+// away.
 let optHooks = null;
 
 function installOptHooks(o) {