@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/observe/deferred.js

@@ -0,0 +1,186 @@
+import { CONFIG_REDERIVE, STATUS_UNINITIALIZED, CONFIG_LAGS, CONFIG_SLOT_NODE, REACTIVE_RECOMPUTING_DEPS, REACTIVE_DISPOSED, REACTIVE_REASK, CONFIG_HELD, NOT_PENDING } from "./core/constants.js";
+
+import { isThenable, handleAsync } from "./core/async.js";
+
+import { NotReadyError } from "./core/error.js";
+
+import "./core/verdict.js";
+
+import { computed } from "./core/core.js";
+
+import { cleanup, getOwner } from "./core/owner.js";
+
+import "./core/dev.js";
+
+import { GlobalQueue, holdNode, txOf, schedule } from "./core/scheduler.js";
+
+import "./core/effect.js";
+
+import { mark, repoll, unmark } from "./affects-marks.js";
+
+import { accessor } from "./signals.js";
+
+// `createDeferred` — an async memo that may lag, but never leads (D-40,
+// docs/create-deferred.md).
+// Once the node has a committed value, its own non-final work is invisible
+// to the graph: its readers keep the committed value and hold nothing, its
+// landings are changes of their own, and only the verdict (`isPending`) and
+// the truth readers (`until`, `refresh`'s waiter) see the flight.
+// Built from parts the engine already has, so core pays nothing for it:
+// - **Read side: the loading window** (`_loading`, async.ts). Every pass of
+//   a node with a committed value opens the window before it asks, so a
+//   flight serves the committed value instead of throwing, and an unready
+//   source parks the node instead of pending it. `CONFIG_REDERIVE` makes a
+//   source going pending a question for the node's pass (which parks) rather
+//   than a status pushed through it to its readers.
+// - **Verdict: a mark** (affects-marks.ts) whose lifetime is the flight —
+//   started when a pass asks a new question (a `refresh()` re-ask is quiet, F-9),
+//   dropped at the landing, the rejection, a sync answer or the node's death.
+// - **Never leads:** a flight that lands while an input it read is held
+//   derived from that hold's world, so it lands into the hold (`holdNode`;
+//   `setSignal` stages it there). An input that changed after the pass
+//   would have superseded the flight, so a held input at the landing is one
+//   the pass read held.
+// - **Truth readers** wait the flight out (`GlobalQueue._lagging`, signals.ts
+//   `watch`): `await refresh(d)` delivers the landing, `until` sees only
+//   settled values.
+/** Deferred nodes with a flight up. */
+const lagging = new Set;
+
+/** The deferred node with a flight up that `c`'s value derives from, if
+ * any: `c` itself, or one reached through its current dependencies. */ function lagOf(e, r) {
+    if (lagging.has(e)) return e;
+    if (r.has(e)) return;
+    r.add(e);
+    if (e.l & CONFIG_SLOT_NODE) return lagOf(e.O?.fam?.node ?? e, r);
+    const t = e.R & REACTIVE_RECOMPUTING_DEPS ? e._ : undefined;
+    if (t !== null) for (let o = e.C ?? null; o !== null; o = o.G) {
+        const e = lagOf(o.S, r);
+        if (e) return e;
+        if (o === t) break;
+    }
+}
+
+GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
+
+/**
+ * Creates an async memo that may lag, but never leads. Before its first
+ * answer it is an ordinary async memo: readers suspend to the nearest
+ * `<Loading>`. After it, a refetch holds nothing: readers keep the last
+ * committed value until the new one lands, and the rest of the screen moves
+ * on without it. `isPending` reports the refetch, on the node and on what
+ * derives from it. Use it for independent widgets (dashboards, feeds,
+ * search results) where the previous answer with a "refreshing" indicator is
+ * better than waiting with everything else.
+ *
+ * - It never shows a value ahead of a held change: a refetch that read a
+ *   held value lands with that hold.
+ * - A rejected refetch errors like any memo; the stale value never masks it.
+ * - `refresh(d)` is a quiet re-ask, and `await refresh(d)` and `until`
+ *   wait for the landing rather than the stale value.
+ * - Combine with `loadingValue` for a node that never suspends at all.
+ *
+ * @example
+ * ```tsx
+ * const rows = createDeferred(() => fetchRows(store.period));
+ *
+ * <section class={{ stale: isPending(() => rows()) }}>
+ *   <For each={rows()}>{row => <Row row={row} />}</For>
+ * </section>
+ * ```
+ */ function createDeferred(e, r) {
+    let t;
+    /** The flight in force: a promise, a stream, or the error an unready
+     * source parked the node with. */    let o = null;
+    let n = false;
+    let l = false;
+    /** The flight `r` is over. An async answer (`held`) arriving while an
+     * input is held lands into that hold first. */    const land = (e, r) => {
+        if (e === null || o !== e) return;
+        o = null;
+        lagging.delete(t);
+        if (r) for (let e = t.C; e !== null; e = e.G) if (e.S.l & CONFIG_HELD) {
+            holdNode(t, txOf(e.S));
+            break;
+        }
+        if (n) {
+            n = false;
+            unmark(t);
+            schedule();
+        }
+    };
+    const ask = e => {
+        o = e;
+        lagging.add(t);
+        if (!n && !(t.R & REACTIVE_REASK)) {
+            n = true;
+            mark(t);
+            repoll(t);
+        }
+    };
+    /** Registers the flight and serves the pass's value: the committed one,
+     * or over a held landing the landing itself, which a lagging question
+     * does not replace (D-40) — restaged as the committed value, the hold's
+     * readers would re-derive against the old input. */    const serve = e => {
+        const r = handleAsync(t, e);
+        return t.l & CONFIG_HELD && t.ue !== NOT_PENDING ? t.ue : r;
+    };
+    const end = () => t.R & REACTIVE_DISPOSED && land(o);
+    return accessor(computed(r => {
+        t = getOwner();
+        t.l |= CONFIG_REDERIVE;
+        cleanup(end);
+        // Answered: the node has a real committed answer — not a first load,
+        // not a `loadingValue` window still open (both are loading, F-9).
+        // 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;
+        try {
+            const t = e(r);
+            if (n && typeof t === "object" && t !== null) {
+                if (isThenable(t)) {
+                    ask(t);
+                    const done = () => land(t, true);
+                    t.then(done, done);
+                    return serve(t);
+                }
+                const e = t[Symbol.asyncIterator];
+                if (e) {
+                    // A stream's flight ends at its first yield (or its end).
+                    const r = e.call(t);
+                    let o = true;
+                    const done = () => land(n, true);
+                    const n = {
+                        // Registered ahead of the engine's own reaction to the same
+                        // promise, as for a plain flight: verdict and value in one flush.
+                        next: e => {
+                            const t = r.next(e);
+                            if (o) {
+                                o = false;
+                                if (isThenable(t)) t.then(done, done); else done();
+                            }
+                            return t;
+                        },
+                        return: e => r.return?.(e) ?? Promise.resolve({
+                            done: true,
+                            value: e
+                        })
+                    };
+                    ask(n);
+                    return serve({
+                        [Symbol.asyncIterator]: () => n
+                    });
+                }
+            }
+            land(o);
+            return t;
+        } 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); else land(o);
+            throw e;
+        }
+    }, r));
+}
+
+export { createDeferred };

package/dist/observe/flatten.js

@@ -0,0 +1,79 @@
+import { NotReadyError } from "./core/error.js";
+
+import "./core/verdict.js";
+
+import "./core/core.js";
+
+import "./core/dev.js";
+
+import "./core/scheduler.js";
+
+import "./core/effect.js";
+
+// CARVE 4: `flatten` lived in boundaries.ts but is the general children
+// resolver the renderers (`web`, `universal`, `solid`'s `children()`) walk
+// through — not a boundary feature. Moved verbatim so the boundary carve
+// measures boundaries alone.
+/**
+ * Resolves nested accessors and arrays in a children tree to their rendered
+ * values. See the `children()` helper in solid-js for the memoized form.
+ */
+function flatten(r, t) {
+    if (typeof r === "function" && !r.length) {
+        if (t?.doNotUnwrap) return r;
+        do {
+            r = r();
+        } while (typeof r === "function" && !r.length);
+    }
+    if (t?.skipNonRendered && (r == null || r === true || r === false || r === "")) return;
+    if (Array.isArray(r)) {
+        let e = [];
+        if (flattenArray(r, e, t)) {
+            return () => {
+                let r = [];
+                flattenArray(e, r, {
+                    ...t,
+                    doNotUnwrap: false
+                });
+                return r;
+            };
+        }
+        return e;
+    }
+    return r;
+}
+
+function flattenArray(r, t = [], e) {
+    let o = null;
+    let f = false;
+    for (let n = 0; n < r.length; n++) {
+        try {
+            let o = r[n];
+            if (typeof o === "function" && !o.length) {
+                if (e?.doNotUnwrap) {
+                    t.push(o);
+                    f = true;
+                    continue;
+                }
+                do {
+                    o = o();
+                } while (typeof o === "function" && !o.length);
+            }
+            if (Array.isArray(o)) {
+                // OR, don't overwrite: an accessor already pushed under doNotUnwrap
+                // still needs the resolving wrapper even when a later sibling
+                // fragment contains no functions (#3133).
+                f = flattenArray(o, t, e) || f;
+            } else if (e?.skipNonRendered && (o == null || o === true || o === false || o === "")) {
+                // skip
+            } else t.push(o);
+        } catch (r) {
+            if (!(r instanceof NotReadyError)) throw r;
+            o = r;
+        }
+    }
+    if (o) throw o;
+    return f;
+}
+
+export { flatten };

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

@@ -0,0 +1,71 @@
+export { ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError } from "./core/error.js";
+
+export { isPending, latest } from "./core/verdict.js";
+
+export { action } from "./core/action.js";
+
+export { clearSnapshots, isEqual, markSnapshotScope, releaseSnapshotScope, runWithOwner, setSnapshotCapture, setWriteHook, untrack } from "./core/core.js";
+
+export { enableExternalSource } from "./core/external.js";
+
+export { createOwner, createRoot, getNextChildId, getObserver, getOwner, isDisposed, peekNextChildId } from "./core/owner.js";
+
+export { setReadWatch, setSignalIdentities, signalName } from "./core/identities.js";
+
+export { createContext, getContext, setContext } from "./core/context.js";
+
+export { $REFRESH, SUPPORTS_PROXY } from "./core/constants.js";
+
+import { OBSERVE as OBSERVE$1 } from "./core/dev.js";
+
+export { setConsoleFooter } from "./core/dev.js";
+
+export { ROOT_ERROR_HOOK, clock, enforceLoadingBoundary, flush, resetErrorHalt } from "./core/scheduler.js";
+
+import "./core/effect.js";
+
+export { configureClientErrors } from "./core/error-hooks.js";
+
+export { checkForeignOwnerless, runAsSolidCopy } from "./core/copies.js";
+
+export { storeName } from "./store/edges.js";
+
+export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onFlush, onSettled, refresh, resolve, until } from "./signals.js";
+
+export { mapArray, repeat } from "./map.js";
+
+export { createStore, deep, reconcile, snapshot } from "./store/index.js";
+
+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";
+
+export { createRevealOrder } from "./reveal.js";
+
+export { $PROXY, $RECORD, $TARGET, $TRACK, isWrappable, markRaw } from "./store/types.js";
+
+export { MergeView, OmitView, SOURCE_MEMO, SOURCE_MERGE, SOURCE_OMIT, SOURCE_PLAIN, SOURCE_PROXY, hasStaticKeys, isStatic, merge, mergeSources, mergeView, omit, omitView, resolvedTable, sourceGet, sourceHas, sourceKeys, sourceOwners, viewOf } from "./store/utils.js";
+
+export { createOptimisticStore } from "./store/optimistic.js";
+
+export { createProjection } from "./store/projection.js";
+
+export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store/store.js";
+
+export { storePath } from "./store/storePath.js";
+
+/**
+ * Observe tier (diagnostics channel, attribution hook slot + interaction
+ * frame): dev and observe builds. The attribution engine itself is the
+ * `@solidjs/signals/attribution` entry.
+ */ const OBSERVE = OBSERVE$1;
+
+/** Dev tier (devtools hooks, graph traversal, console reporting): dev builds only. */ const DEV = undefined;
+
+export { DEV, OBSERVE };