@solidjs/signals 2.0.0-rc.16 → 2.0.0-rc.18

package/dist/observe/core/verdict.js

@@ -139,8 +139,8 @@ let probeFound = false;
  * when every flight it waits on is. */ function quietPending(e) {
     const t = e.T;
     if (t === null) return false;
-    if (t.fe !== undefined) {
-        for (const e of t.fe) if (!e.T?.ut) return false;
+    if (t.se !== undefined) {
+        for (const e of t.se) if (!e.T?.ut) return false;
         return true;
     }
     return t.ut;
@@ -323,6 +323,9 @@ let probeFound = false;
         const u = (n.m & STATUS_PENDING) !== 0 && !quietPending(n);
         if (e.l & CONFIG_GUESS) {
             if (probing && (u || e.ue !== NOT_PENDING && (!e.Ye || !e.Ye(e.T.V, e.ue)))) probeFound = true;
+            // A lane a correction folded under (D-34): `latest()` shows the hold's
+            // world whole — the truth beneath each guess, else what it covered.
+                        if (latestActive && r.folded) return r.folded(null, e);
             return e.T.V;
         }
         if (probing && u) probeFound = true;

package/dist/observe/deferred.js

@@ -135,26 +135,26 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
         // Sticky, and read before this wrapper ever opens the window itself.
                 const n = l ||= !(t.m & STATUS_UNINITIALIZED) && !t.ce;
         if (n) t.ce = true, t.l |= CONFIG_LAGS;
-        let c;
+        let s;
         try {
-            c = e(r);
+            s = e(r);
         } catch (e) {
             // The wrapping form: an unready source parks the node in the window,
             // and the wait is its flight until the source's settle re-runs it.
-            if (n && e instanceof NotReadyError) ask(e);
+            if (n && e instanceof NotReadyError) ask(e); else land(o);
             throw e;
         }
-        if (n && typeof c === "object" && c !== null) {
-            if (isThenable(c)) {
-                ask(c);
-                const done = () => land(c, true);
-                c.then(done, done);
-                return serve(c);
+        if (n && typeof s === "object" && s !== null) {
+            if (isThenable(s)) {
+                ask(s);
+                const done = () => land(s, true);
+                s.then(done, done);
+                return serve(s);
             }
-            const e = c[Symbol.asyncIterator];
+            const e = s[Symbol.asyncIterator];
             if (e) {
                 // A stream's flight ends at its first yield (or its end).
-                const r = e.call(c);
+                const r = e.call(s);
                 let t = true;
                 const done = () => land(o, true);
                 const o = {
@@ -162,7 +162,10 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
                     // promise, as for a plain flight: verdict and value in one flush.
                     next: e => {
                         const o = r.next(e);
-                        if (t) t = false, o.then(done, done);
+                        if (t) {
+                            t = false;
+                            if (isThenable(o)) o.then(done, done); else done();
+                        }
                         return o;
                     },
                     return: e => r.return?.(e) ?? Promise.resolve({
@@ -177,7 +180,7 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
             }
         }
         land(o);
-        return c;
+        return s;
     }, r));
 }
 

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

@@ -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

@@ -305,7 +305,7 @@ function updateKeyedMap() {
                 this.Kt && (this.Kt = []);
                 this.xt && (this.xt = []);
             }
-            if (this.L && !this.vt[0]) {
+            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();
@@ -543,7 +543,7 @@ function updateRepeat() {
                 // Reset offset to match the cleared data (#2767, repro 2).
                                 this.$t = 0;
             }
-            if (this.L && !this.vt[0]) {
+            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();

package/dist/observe/signals.js

@@ -296,7 +296,12 @@ function createMemo(e, t) {
             o = undefined;
         }
         runWithOwner(n, () => {
-            effect(() => (c(), o = getOwner()), t => {
+            effect(() => {
+                const e = getOwner();
+                o = e;
+                c();
+                return e;
+            }, t => {
                 o = undefined;
                 r?.();
                 const n = (e.effect || e)?.();

package/dist/observe/store/affects.js

@@ -38,8 +38,8 @@ const scopes = new Map;
 function scopeOf(e, o) {
     let n = scopes.get(e);
     if (n === undefined) scopes.set(e, n = {
-        eo: new Set,
-        oo: [],
+        oo: new Set,
+        no: [],
         Vt: o
     });
     return n;
@@ -47,15 +47,15 @@ function scopeOf(e, o) {
 
 /** The nodes an `affects(store[, key])` declaration marks (affects.ts
  * registers each). */ function storeMarks(e, o) {
-    const n = GlobalQueue.no(e, o === undefined ? $AFFECTS : o);
+    const n = GlobalQueue.so(e, o === undefined ? $AFFECTS : o);
     const t = scopeOf(n, o);
     if (o === undefined) {
         const o = [ n ];
         walk(e.px, t, o, e.fam, new Set);
         return o;
     }
-    t.eo.add(e.v);
-    if (e.pb !== null) t.eo.add(e.pb);
+    t.oo.add(e.v);
+    if (e.pb !== null) t.oo.add(e.pb);
     return [ n ];
 }
 
@@ -63,14 +63,14 @@ function scopeOf(e, o) {
  * the committed backing both, when a draft is open; an optimistic family's
  * view), every live node under each record into `found`. Untracked by
  * construction: raws, never traps. */ function walk(e, o, n, t, s) {
-    if (!GlobalQueue.so(e)) return;
+    if (!GlobalQueue.fo(e)) return;
     const f = e[$TARGET] ?? lookupTarget(e, t);
     let r = f !== undefined ? f.pb ?? f.v : e;
     if (s.has(r)) return;
     s.add(r);
-    o.eo.add(r);
+    o.oo.add(r);
     if (f !== undefined) {
-        if (f.pb !== null) o.eo.add(f.v);
+        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);
         const e = f.n;
@@ -96,7 +96,7 @@ function scopeOf(e, o) {
     for (const [t, s] of scopes) {
         if (t === n || s.Vt !== undefined && s.Vt !== o) continue;
         for (let o = e.v; ;) {
-            if (s.eo.has(o)) return t;
+            if (s.oo.has(o)) return t;
             const e = o?.[$TARGET];
             if (e === undefined) break;
             const n = e.pb ?? e.v;
@@ -112,17 +112,17 @@ function scopeOf(e, o) {
  * no work. */ const hooks = {
     // A node born on a record a live mark covers inherits it (released with
     // the carrier's last registration).
-    fo(e, o, n) {
+    ro(e, o, n) {
         if (scopes.size === 0 || n === $AFFECTS) return;
         const t = covering(e, n, o);
         if (!t) return;
         GlobalQueue.N(o);
-        scopes.get(t).oo.push(o);
+        scopes.get(t).no.push(o);
     },
     // An untracked probe (`isPending(() => s.x)` with no observer) reading a
     // record a live mark covers: no node carries the mark for it — the
     // verdict is told directly.
-    ro(e, o) {
+    io(e, o) {
         if (e.n?.[$AFFECTS]?.T?.I || covering(e, o)) GlobalQueue.bt();
     }
 };
@@ -136,7 +136,7 @@ function scopeOf(e, o) {
     const o = scopes.get(e);
     if (o === undefined) return;
     scopes.delete(e);
-    releaseMarksHook(o.oo);
+    releaseMarksHook(o.no);
 }
 
 export { installStoreAffects, releaseMarkScope, storeMarks };