@solidjs/signals 2.0.0-rc.13 → 2.0.0-rc.14

package/dist/prod/reveal.js

@@ -0,0 +1,212 @@
+import { runWithOwner, untrack, computed } from "./core/core.js";
+
+import { createOwner, cleanup } from "./core/owner.js";
+
+import { REVEAL, ready, redraw, setRevealHooks } from "./boundaries.js";
+
+/**
+ * Reveal order — `createRevealOrder` (`<Reveal>`): the order in which a group
+ * of Loading boundaries (its direct slots) may show their content.
+ *
+ * A controller owns each slot until the slot has shown content, and forces
+ * on the slots it owns the state the order dictates: gated (the fallback,
+ * whatever the content's state) and, in a collapsed sequential tail, nothing
+ * at all. A nested reveal order is a composite slot of its parent — gated,
+ * it gates all of its own; released, it runs its own order.
+ *
+ * - `sequential`: slots reveal front to back. The first unready slot is the
+ *   frontier — its fallback shows; the slots behind it are gated (collapsed
+ *   when `collapsed`); the ones before it have revealed.
+ * - `together`: every owned slot is gated until all are minimally ready;
+ *   then all are released at once.
+ * - `natural`: each slot reveals on its own as it becomes ready.
+ *
+ * A slot graduates when it shows content: a later re-arm of it gates nobody
+ * else, and slots appended after graduation form a fresh frontier. The
+ * boundary tells the controller when its readiness changed (boundaries.ts:
+ * caught, settled, shown, disposed); `order`/`collapsed` are tracked by a
+ * computed of the group's own.
+ */ const FALSE_ACCESSOR = () => false;
+
+const SEQUENTIAL_ACCESSOR = () => "sequential";
+
+const isController = t => t instanceof RevealController;
+
+const slotReady = t => isController(t) ? t.Rt() : ready(t);
+
+const slotMinReady = t => isController(t) ? t.Ct() : ready(t);
+
+/** Force a slot's state. A boundary re-derives its output when it changes;
+ * a nested controller passes the state on to its own slots. Released
+ * (`!gated`), a nested controller leaves its parent's ownership and runs its
+ * own order; a boundary leaves when it has shown content (boundaries.ts). */ function setSlotState(t, e, s, r) {
+    if (isController(t)) {
+        t.te = s;
+        t.le = r;
+        t.vt();
+        // Released and ready — every slot of its own has shown — it graduates,
+        // as a boundary does when it shows content. Released at the frontier
+        // but not ready, it stays the parent's frontier.
+                if (!s && t.Lt && t._parent === e) t._parent = null;
+        return;
+    }
+    if (t.te !== s || t.le !== r) {
+        t.te = s;
+        t.le = r;
+        redraw(t);
+    }
+}
+
+class RevealController {
+    qt;
+    Vt;
+    Ft=[];
+    /** The controller gating this one, until it releases this one. */
+    _parent=null;
+    /** The state a parent forces on this whole group. */
+    te=false;
+    le=false;
+    Lt=true;
+    Qt=true;
+    Ut=false;
+    constructor(t, e) {
+        this.qt = t;
+        this.Vt = e;
+    }
+    /** A slot that has left this controller's ownership: a boundary that has
+     * shown content, a nested group that is ready. Shown is shown — it counts
+     * as ready whatever happens to it later (a re-arm gates nobody else). */    bt(t) {
+        return (isController(t) ? t._parent : t.B) !== this;
+    }
+    /** The slots this controller still owns, in registration order — the
+     * ones the order's state is forced on. */    xt(t) {
+        for (let e = 0; e < this.Ft.length; e++) {
+            const s = this.Ft[e];
+            if (!this.bt(s) && t(s) === false) return false;
+        }
+        return true;
+    }
+    /** Readiness is judged over every slot, done ones as ready. */    Rt() {
+        for (let t = 0; t < this.Ft.length; t++) {
+            const e = this.Ft[t];
+            if (!this.bt(e) && !slotReady(e)) return false;
+        }
+        return true;
+    }
+    /** Something visible to show under its own order — what an enclosing
+     * `together` waits for: `together` — every slot minimally ready;
+     * `sequential` — the first slot; `natural` — any. */    Ct() {
+        const t = untrack(this.qt);
+        const e = this.Ft;
+        if (e.length === 0) return true;
+        if (t === "sequential") return this.bt(e[0]) || slotMinReady(e[0]);
+        for (let s = 0; s < e.length; s++) {
+            const r = this.bt(e[s]) || slotMinReady(e[s]);
+            if (t === "natural" ? r : !r) return t === "natural";
+        }
+        return t !== "natural";
+    }
+    ae(t) {
+        if (this.Ft.includes(t)) return;
+        this.Ft.push(t);
+        // Gated from the start (collapsed in a collapsed sequential tail); the
+        // evaluation releases what the order allows.
+                const e = untrack(this.qt) === "sequential" && !!untrack(this.Vt);
+        if (isController(t)) {
+            t._parent = this;
+            t.te = true;
+            t.le = e;
+            t.vt();
+        } else {
+            t.B = this;
+            t.te = true;
+            t.le = e;
+        }
+        untrack(() => this.vt());
+    }
+    ue(t) {
+        const e = this.Ft.indexOf(t);
+        if (e >= 0) this.Ft.splice(e, 1);
+        untrack(() => this.vt());
+    }
+    /** Apply the order to the owned slots — or, gated by a parent, its state
+     * to all of them. */    vt() {
+        if (this.Ut) return;
+        this.Ut = true;
+        const t = this.Lt;
+        const e = this.Qt;
+        try {
+            const t = untrack(this.qt);
+            const e = t === "sequential" && !!untrack(this.Vt);
+            if (this.te) {
+                this.xt(t => setSlotState(t, this, true, this.le));
+            } else if (t === "natural") {
+                this.xt(t => {
+                    if (isController(t)) setSlotState(t, this, false, false); else setSlotState(t, this, !ready(t), false);
+                });
+            } else if (t === "together") {
+                const t = this.xt(slotMinReady);
+                this.xt(e => setSlotState(e, this, !t, false));
+            } else {
+                let t = false;
+                this.xt(s => {
+                    if (t) return setSlotState(s, this, true, e);
+                    if (slotReady(s)) return setSlotState(s, this, false, false);
+                    t = true;
+                    // The frontier: its fallback shows; a nested controller at the
+                    // frontier runs its own order.
+                                        setSlotState(s, this, isController(s) ? false : true, false);
+                });
+            }
+        } finally {
+            this.Lt = this.Rt();
+            this.Qt = this.Ct();
+            this.Ut = false;
+        }
+        if (this._parent !== null && (t !== this.Lt || e !== this.Qt)) this._parent.vt();
+    }
+}
+
+/**
+ * Lower-level primitive behind `<Reveal>`: coordinates the order in which the
+ * Loading boundaries created directly inside `fn` reveal their content.
+ *
+ * @param fn the subtree; the Loading boundaries it creates directly are the
+ *   group's slots, a nested `createRevealOrder` a composite slot
+ * @param options `order` — `"sequential"` (default: front to back, the
+ *   first unready slot showing its fallback), `"together"` (all at once),
+ *   `"natural"` (each on its own); `collapsed` — in a sequential group, the
+ *   slots behind the frontier render nothing instead of their fallbacks
+ */ function createRevealOrder(t, e) {
+    const s = createOwner();
+    const r = s.U[REVEAL];
+    const i = new RevealController(e?.order || SEQUENTIAL_ACCESSOR, e?.collapsed || FALSE_ACCESSOR);
+    s.U = {
+        ...s.U,
+        [REVEAL]: i
+    };
+    return runWithOwner(s, () => {
+        const e = t();
+        const s = computed(() => {
+            i.qt();
+            i.Vt();
+            i.vt();
+        });
+        if (false) ;
+        if (r) {
+            r.ae(i);
+            cleanup(() => r.ue(i));
+        }
+        return e;
+    });
+}
+
+// Installed at module evaluation — present exactly when something imports
+// `createRevealOrder`; a Loading boundary without one pays a null check.
+setRevealHooks({
+    ae: (t, e) => t.ae(e),
+    ue: (t, e) => t.ue(e),
+    j: t => t.vt()
+});
+
+export { createRevealOrder };