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

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/store/reconcile.js

@@ -24,15 +24,15 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
  * identity), unkeyed items fall back to position.
  */ function reconcileState(e, n, t, o = false) {
     if (n == null) throw new Error("");
-    const f = n?.[$TARGET];
-    if (f === undefined || f.px !== n) throw new Error("");
-    const l = t === null ? null : typeof t === "string" ? e => e?.[t] : t;
+    const f = n[$TARGET];
+    if (f?.px !== n) throw new Error("");
+    const i = t === null ? null : typeof t === "string" ? e => e?.[t] : t;
     // A user's reconcile on an optimistic family (S4): not an adoption of
     // truth but an optimistic edit — the keyed diff is written into the draft
     // (a matched row keeps its proxy, its changed leaves become its guesses),
     // and the setter's exit turns the draft into guesses like any.
         if (userWriting() && f.fam?.opt === true) {
-        optHooks.reconcile(n, unwrapValue(e), l);
+        optHooks.reconcile(n, unwrapValue(e), i);
         return;
     }
     // Replace-mode root handed another store's proxy: chain to it (§7b).
@@ -43,21 +43,20 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
                 adoptPB(f, e);
         return;
     }
-    const i = unwrapValue(e);
-    if (l) {
+    const l = unwrapValue(e);
+    if (i) {
         const e = f.pb ?? f.v;
-        const n = l(e);
-        if (n !== undefined && !sameKey(l(i), n)) {
+        const n = i(e);
+        if (n !== undefined && !sameKey(i(l), n)) {
             if (!o) throw new Error("");
             // A different entity at the root: the old backing is disowned (wraps
             // fresh if re-handed) and the new one adopted whole.
-                        const e = f.pb ?? f.v;
-            if (isOwned(e)) delete e[$OWNER]; else (f.fam?.map ?? storeLookup).delete(e);
-            adoptPB(f, i);
+                        if (isOwned(e)) delete e[$OWNER]; else (f.fam?.map ?? storeLookup).delete(e);
+            adoptPB(f, l);
             return;
         }
     }
-    applyAdopt(f, i, l, o);
+    applyAdopt(f, l, i, o);
 }
 
 /** Adopt `incoming` at `t` and notify its nodes — one leaf write per
@@ -70,190 +69,207 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
     // a deletion here (#3743: the presence and value diffs both read `old`).
     const f = e.ovl ? materializePB(e) : e.pb ?? e.v;
     if (n === f && !isOwned(f)) return;
-    const l = e.fam;
     // Q-D: a landing on an optimistic family is reconciled against the VIEW
     // — key matching from the arrangement the guesses made (R28), so a row
     // the guess added keeps its proxy when the server returns it.
-        const i = l?.opt === true ? optHooks.view(e, f) : f;
-    const s = Array.isArray(n);
-    const u = e.s === true;
-    const r = f;
+        const i = e.fam?.opt === true ? optHooks.view(e, f) : f;
+    const l = Array.isArray(n);
+    const r = e.s === true;
     adoptPB(e, n, false);
-    if (u) markRawIngest(n);
-    if (Array.isArray(i) !== s) {
-        notifyFold(e, r, n);
+    if (r) markRawIngest(n);
+    // The deep witness is bumped once per adoption (none to bump: done).
+        let u = e.dk === null;
+    if (Array.isArray(i) !== l) {
+        notifyFold(e, f, n);
         return;
     }
-    if (s) {
-        const f = i;
-        const s = n;
-        const a = e.n;
-        let c = 0;
-        if (t && !u) {
-            const i = f.length;
-            const u = s.length;
-            let d = false;
-            let p = 0;
+    if (l) {
+        const l = e.n;
+        let s = 0;
+        if (t && !r) {
+            const r = i.length;
+            const a = n.length;
+            let c = 0;
             // Aligned prefix: same row (by reference or key) at the same index.
-                        for (const y = Math.min(i, u); p < y; p++) {
-                const i = s[p];
-                const u = f[p];
-                if (u !== i && !sameRow(u, i, t)) break;
+                        for (const d = Math.min(r, a); c < d; c++) {
+                const r = n[c];
+                const a = i[c];
+                if (a !== r && !sameRow(a, r, t)) break;
  // misaligned: fall to the keyed remainder below
-                                if ((u !== i || i !== null && typeof i === "object" && isOwned(i)) && i !== null && typeof i === "object") descend(unwrapValue(u), i, t, l, o);
-                if (e.dk !== null && !d && !(i !== null && typeof i === "object" ? targetsEqual(u, i) : isEqual(u, i))) {
+                                if (r !== null && typeof r === "object" && (a !== r || isOwned(r))) descend(unwrapValue(a), r, t, o, e, c);
+                if (!u && !(r !== null && typeof r === "object" ? targetsEqual(a, r) : isEqual(a, r))) {
                     bumpDeep(e);
-                    d = true;
+                    u = true;
                 }
-                if (a !== null) {
-                    const e = a[p];
+                if (l !== null) {
+                    const e = l[c];
                     if (e !== undefined) {
-                        c++;
-                        notifyKeyValue(e, p, r[p], i, r, n);
+                        s++;
+                        notifyKeyValue(e, c, f[c], r, f, n);
                     }
                 }
             }
-            if (e.dk !== null && !d && p < s.length) bumpDeep(e);
-            const y = p;
+            if (!u && c < n.length) bumpDeep(e);
+            const d = c;
  // misalignment point (== nlen on aligned ticks)
-                        let w = null;
-            for (;p < s.length; p++) {
-                const e = s[p];
-                if (e !== null && typeof e === "object") {
-                    const n = t(e);
-                    let i;
+                        let p = null;
+            for (;c < n.length; c++) {
+                const r = n[c];
+                if (r !== null && typeof r === "object") {
+                    const n = t(r);
+                    let f;
                     if (n !== undefined) {
-                        if (w === null) {
-                            w = new Map;
-                            for (let e = y; e < f.length; e++) {
-                                const n = unwrapValue(f[e]);
+                        if (p === null) {
+                            p = new Map;
+                            for (let e = d; e < i.length; e++) {
+                                const n = unwrapValue(i[e]);
                                 if (n !== null && typeof n === "object") {
                                     const o = t(n);
                                     if (o === undefined) continue;
-                                    const f = w.get(o);
-                                    if (f === undefined) w.set(o, e); else if (Array.isArray(f)) f.push(e); else w.set(o, [ f, e ]);
+                                    const f = p.get(o);
+                                    if (f === undefined) p.set(o, e); else if (Array.isArray(f)) f.push(e); else p.set(o, [ f, e ]);
                                 }
                             }
                         }
-                        const e = w.get(n);
-                        if (e === undefined) i = undefined; else if (Array.isArray(e)) {
-                            i = unwrapValue(f[e.shift()]);
-                            if (e.length === 1) w.set(n, e[0]);
+                        const e = p.get(n);
+                        if (e === undefined) f = undefined; else if (Array.isArray(e)) {
+                            f = unwrapValue(i[e.shift()]);
+                            if (e.length === 1) p.set(n, e[0]);
                         } else {
-                            i = unwrapValue(f[e]);
-                            w.delete(n);
+                            f = unwrapValue(i[e]);
+                            p.delete(n);
                         }
                     } else {
-                        i = unwrapValue(f[p]);
+                        f = unwrapValue(i[c]);
  // keyless item: positional fallback
                                         }
-                    descend(i, e, t, l, o);
+                    descend(f, r, t, o, e, c);
                 }
-                if (a !== null) {
-                    const e = a[p];
+                if (l !== null) {
+                    const e = l[c];
                     if (e !== undefined) {
-                        c++;
-                        notifyKeyDiff(e, p, r, n, false);
+                        s++;
+                        notifyKeyDiff(e, c, f, n, false);
                     }
                 }
             }
         } else {
-            const i = Math.min(f.length, s.length);
-            const d = s.length;
-            let p = false;
-            for (let y = 0; y < d; y++) {
-                const d = s[y];
-                if (!u && y < i && d !== null && typeof d === "object") descend(unwrapValue(f[y]), d, t, l, o);
-                if (e.dk !== null && !p && !(d !== null && typeof d === "object" ? targetsEqual(f[y], d) : isEqual(f[y], d))) {
+            const a = Math.min(i.length, n.length);
+            const c = n.length;
+            for (let d = 0; d < c; d++) {
+                const c = n[d];
+                if (!r && d < a && c !== null && typeof c === "object") descend(unwrapValue(i[d]), c, t, o, e, d);
+                if (!u && !(c !== null && typeof c === "object" ? targetsEqual(i[d], c) : isEqual(i[d], c))) {
                     bumpDeep(e);
-                    p = true;
+                    u = true;
                 }
-                if (a !== null) {
-                    const e = a[y];
+                if (l !== null) {
+                    const e = l[d];
                     if (e !== undefined) {
-                        c++;
-                        notifyKeyDiff(e, y, r, n, false);
+                        s++;
+                        notifyKeyDiff(e, d, f, n, false);
                     }
                 }
             }
         }
         // Indices past the new length (and `length` itself) still have nodes.
-                if (a !== null && c < e.nc) {
-            for (const e of Reflect.ownKeys(a)) {
+                if (l !== null && s < e.nc) {
+            for (const e of Reflect.ownKeys(l)) {
                 const t = typeof e === "string" ? +e : NaN;
-                if (!(t >= 0 && t < s.length)) notifyKeyDiff(a[e], e, r, n, false);
+                if (!(t >= 0 && t < n.length)) notifyKeyDiff(l[e], e, f, n, false);
             }
         }
-        notifyFoldTail(e, r, n);
+        notifyFoldTail(e, f, n);
         return;
     }
-    const a = e.n;
-    let c = 0;
-    let d = false;
-    for (const f in n) {
-        const s = n[f];
-        const p = r[f];
-        const y = s !== null && typeof s === "object";
-        if (p === s && (!y || !isOwned(s)) && (a === null || a[f] === undefined || !hasAccessorFlag(a[f]))) {
-            if (a !== null && a[f] !== undefined) c++;
+    const s = e.n;
+    let a = 0;
+    for (const l in n) {
+        const c = n[l];
+        const d = f[l];
+        const p = c !== null && typeof c === "object";
+        if (d === c && (!p || !isOwned(c)) && (s === null || s[l] === undefined || !hasAccessorFlag(s[l]))) {
+            if (s?.[l] !== undefined) a++;
             continue;
         }
-        if (y && !u) descend(unwrapValue(i[f]), s, t, l, o);
-        if (e.dk !== null && !d && !(y ? targetsEqual(p, s) : isEqual(p, s))) {
+        if (p && !r) descend(unwrapValue(i[l]), c, t, o, e, l);
+        if (!u && !(p ? targetsEqual(d, c) : isEqual(d, c))) {
             bumpDeep(e);
-            d = true;
+            u = true;
         }
-        if (a !== null) {
-            const e = a[f];
+        if (s !== null) {
+            const e = s[l];
             if (e !== undefined) {
-                c++;
-                notifyKeyValue(e, f, p, s, r, n);
+                a++;
+                notifyKeyValue(e, l, d, c, f, n);
             }
         }
     }
-    const p = Object.getOwnPropertySymbols(n);
-    for (let e = 0; e < p.length; e++) {
-        const f = p[e];
-        if (f === $OWNER) continue;
-        const i = n[f];
-        if (!u && i !== null && typeof i === "object") descend(unwrapValue(r[f]), i, t, l, o);
-        if (a !== null) {
-            const e = a[f];
+    const c = Object.getOwnPropertySymbols(n);
+    for (let i = 0; i < c.length; i++) {
+        const l = c[i];
+        if (l === $OWNER) continue;
+        const u = n[l];
+        if (!r && u !== null && typeof u === "object") descend(unwrapValue(f[l]), u, t, o, e, l);
+        if (s !== null) {
+            const e = s[l];
             if (e !== undefined) {
-                c++;
-                notifyKeyValue(e, f, r[f], i, r, n);
+                a++;
+                notifyKeyValue(e, l, f[l], u, f, n);
             }
         }
     }
     // Keys the incoming object no longer has still have nodes.
-        if (a !== null && c < e.nc) {
-        for (const e of Reflect.ownKeys(a)) {
-            if (!hasOwnP.call(n, e)) notifyKeyDiff(a[e], e, r, n, false);
+        if (s !== null && a < e.nc) {
+        for (const e of Reflect.ownKeys(s)) {
+            if (!hasOwnP.call(n, e)) notifyKeyDiff(s[e], e, f, n, false);
         }
     }
-    notifyFoldTail(e, r, n);
+    notifyFoldTail(e, f, n);
 }
 
 const hasOwnP = Object.prototype.hasOwnProperty;
 
 /** Descend into a changed child pair — only where something is proxied
  * below (§6d), never into a raw-marked leaf, never across array/object or a
- * key mismatch (that is a replacement, handled by the parent's slot). */ function descend(e, n, t, o, f = false) {
-    if (e === null || typeof e !== "object" || n === null || typeof n !== "object") return;
-    const l = lookupTarget(e, o);
-    if (l === undefined) return;
+ * key mismatch (that is a replacement, handled by the parent's slot).
+ *
+ * A raw in both frames (the same objects swapped, reordered or shifted,
+ * #4001) must not leave two slots on one row. A raw already a live row keeps
+ * it at the slot it moved to; a row's `pk` follows the slot it sits at (a
+ * move or a pairing writes it), so a row whose raw is at that slot of the
+ * incoming frame is spoken for and not paired again here; a raw still
+ * resolving to a row that moved on drops the lookup (it wraps fresh, or is
+ * paired here). One lookup of `nv` on the common path, no allocation. */ function descend(e, n, t, o, f, i) {
+    // `nv` is an object at every call site.
+    if (e === null || typeof e !== "object") return;
+    const l = f.fam;
+    n = unwrapValue(n);
+    let r = lookupTarget(e, l);
+    const u = lookupTarget(n, l);
+    if (r !== undefined && r.pk !== i) {
+        if (r.pk != i && f.v[r.pk] === r.v) r = undefined; else if (r.u === f) r.pk = i;
+    }
+    if (u !== undefined && u !== r) {
+        if (u.v === n) {
+            if (u.u === f) u.pk = i;
+            return;
+        }
+        (l?.map ?? storeLookup).delete(n);
+    }
+    if (r === undefined) return;
  // nothing proxied below this pair
         if (!isWrappable(n)) return;
     if (rawValuesUsed && isRawValue(n)) return;
-    n = unwrapValue(n);
     if (Array.isArray(e) !== Array.isArray(n)) return;
-    if (t) {
+    // An array slot was paired by key already (or both rows are keyless).
+        if (typeof i !== "number" && t) {
         const o = t(e);
         const f = t(n);
         if (o !== undefined && f !== undefined && !sameKey(o, f)) return;
     }
-    if (!f && t !== null && !l.d) return;
-    applyAdopt(l, n, t, f);
+    if (!o && t !== null && !r.d) return;
+    applyAdopt(r, n, t, o);
 }
 
 export { reconcileState };