uneventful 0.0.7 → 0.0.8

package/dist/signals.mjs

@@ -1,6 +1,28 @@
-import { N as swapCtx, O as nullCtx, P as ruleQueue, c as backpressure, Q as defaultQ, I as IsStream, q as current, R as currentRule, S as makeCtx, T as ruleStops, d as defer, D as makeJob, j as isError, h as markHandled, e as detached, g as getJob, w as reject, b as resolve, U as freeCtx, o as callOrWait } from './call-or-wait-DHkBd_bM.mjs';
-import { apply, setMap, CallableObject } from './utils.mjs';
+import { M as swapCtx, N as nullCtx, c as backpressure, I as IsStream, p as current, O as makeCtx, B as makeJob, h as isError, f as markHandled, d as detached, g as getJob, v as reject, b as resolve, P as freeCtx, l as callOrWait } from './call-or-wait-COAmx32w.mjs';
+import { b as batch, a as arrayEq, d as defer, c as apply, s as setMap, C as CallableObject } from './utils-P0JEpWXG.mjs';
 
+const ruleQueues = /* @__PURE__ */ new WeakMap();
+function ruleQueue(scheduleFn = defer) {
+  ruleQueues.has(scheduleFn) || ruleQueues.set(scheduleFn, batch(runRules$1, scheduleFn));
+  return ruleQueues.get(scheduleFn);
+}
+var currentRule;
+const ruleStops = /* @__PURE__ */ new WeakMap();
+const defaultQ = /* @__PURE__ */ ruleQueue(defer);
+var currentQueue;
+function runRules$1(q) {
+  if (currentQueue)
+    return;
+  currentQueue = this;
+  try {
+    for (currentRule of q) {
+      currentRule.catchUp();
+      q.delete(currentRule);
+    }
+  } finally {
+    currentQueue = currentRule = void 0;
+  }
+}
 class WriteConflict extends Error {
 }
 class CircularDependency extends Error {
@@ -8,7 +30,11 @@ class CircularDependency extends Error {
 var timestamp = 1;
 const fntrackers = /* @__PURE__ */ new WeakMap();
 const obtrackers = /* @__PURE__ */ new WeakMap();
-const streamtrackers = /* @__PURE__ */ new WeakMap();
+const monitors = /* @__PURE__ */ new WeakMap();
+const demandChanges = batch((q) => {
+  for (const cell of q)
+    cell.updateDemand();
+});
 const dirtyStack = [];
 function markDependentsDirty(cell) {
   const latestSource = cell.latestSource = timestamp;
@@ -58,9 +84,17 @@ function mksub(source, target) {
     target.sources.nS = sub;
   target.sources = sub;
   source.adding = sub;
-  if (target.subscribers || target.queue)
+  if (target.flags & 1 /* Observed */)
     source.subscribe(sub);
 }
+function removeConstListener(sub) {
+  const { tgt, nS, pS } = sub;
+  if (sub.src.adding === sub)
+    sub.src.adding = sub.old;
+  delsub(sub);
+  if (tgt.sources === sub)
+    (tgt.sources = nS || pS) || tgt.becomeConstant();
+}
 function delsub(sub) {
   sub.src.unsubscribe(sub);
   if (sub.nS)
@@ -71,25 +105,29 @@ function delsub(sub) {
   sub.old = freesubs;
   freesubs = sub;
 }
-function subscribeAll(s) {
-  if (s)
-    while (s.pS)
-      s = s.pS;
-  else
-    return;
-  for (; s; s = s.nS)
+function subscribeAll(c) {
+  for (let s = firstSource(c); s; s = s.nS)
     s.src.subscribe(s);
+  toggleDemand(c);
 }
-function unsubscribeAll(s) {
+function unsubscribeAll(c) {
+  for (let s = firstSource(c); s; s = s.nS)
+    s.src.unsubscribe(s);
+  toggleDemand(c);
+}
+const sentinel = {};
+function firstSource(c) {
+  let s = c.sources;
   if (s)
     while (s.pS)
       s = s.pS;
-  else
-    return;
-  for (; s; s = s.nS)
-    s.src.unsubscribe(s);
+  return s;
+}
+function toggleDemand(c) {
+  if (((c.flags ^= 1 /* Observed */) & 64 /* Stateful */) === 64 /* Stateful */) {
+    demandChanges.has(c) ? demandChanges.delete(c) : demandChanges.add(c);
+  }
 }
-const sentinel = {};
 class Cell {
   constructor() {
     this.value = void 0;
@@ -111,7 +149,7 @@ class Cell {
     this.queue = void 0;
     /**
      * The computation to be performed (if {@link Is.Compute}) or the
-     * setup/teardown for {@link Is.Stream}.
+     * setup/teardown for {@link Is.Stateful}.
      */
     this.compute = returnValue;
   }
@@ -133,7 +171,6 @@ class Cell {
   getValue() {
     if (arguments.length)
       return apply(this.stream, this, arguments);
-    this.catchUp();
     const dep = current.cell;
     if (dep && this.flags & 132 /* Variable */) {
       if (this.flags & 32 /* Running */)
@@ -141,6 +178,7 @@ class Cell {
       let s = this.adding;
       if (!s || s.tgt !== dep) {
         mksub(this, dep);
+        s = this.adding;
       } else {
         if (s.ts === -1) {
           s.ts = this.lastChanged;
@@ -155,7 +193,11 @@ class Cell {
           }
         }
       }
-    }
+      this.catchUp();
+      if (this.adding === s)
+        s.ts = this.lastChanged;
+    } else
+      this.catchUp();
     if (this.flags & 16 /* Error */)
       throw this.value;
     return this.value;
@@ -232,7 +274,10 @@ class Cell {
       return this.doRecalc();
   }
   doRecalc() {
-    const oldCtx = swapCtx(this.ctx);
+    const { ctx } = this, oldCtx = swapCtx(ctx);
+    if (this.flags & 64 /* Stateful */) {
+      ctx.job?.restart();
+    }
     for (let sub = this.sources; sub; sub = sub.nS) {
       sub.ts = -1;
       sub.old = sub.src.adding;
@@ -257,6 +302,15 @@ class Cell {
       }
     } finally {
       this.flags &= ~32 /* Running */;
+      if (this.flags & 64 /* Stateful */) {
+        demandChanges.delete(this);
+        if (this.flags & (16 /* Error */ | 2 /* Stopped */)) {
+          this.flags &= ~2 /* Stopped */;
+          ctx.job?.restart();
+        } else if (this.flags & 1 /* Observed */) ; else {
+          ctx.job?.restart();
+        }
+      }
       swapCtx(oldCtx);
       let head;
       for (let sub = this.sources; sub; ) {
@@ -269,34 +323,50 @@ class Cell {
           head = sub;
         sub = pS;
       }
-      this.sources = head;
-      if (!head) {
-        this.flags &= ~4 /* Compute */;
-      }
+      (this.sources = head) || this.becomeConstant();
+    }
+  }
+  becomeConstant() {
+    if (this.flags & (32 /* Running */ | 64 /* Stateful */))
+      return;
+    this.flags &= ~4 /* Compute */;
+    if (this.flags & 132 /* Variable */)
+      return;
+    while (this.adding)
+      removeConstListener(this.adding);
+    for (let sub = this.subscribers; sub; ) {
+      const { nT } = sub;
+      sub.ts !== this.lastChanged || removeConstListener(sub);
+      sub = nT;
     }
   }
   stop() {
     this.setQ(null);
+    if (this.flags & 32 /* Running */) {
+      this.flags |= 2 /* Stopped */;
+    } else
+      this.updateDemand();
     ruleStops.get(this)?.();
   }
   setQ(queue = defaultQ) {
-    queue || this.subscribers || unsubscribeAll(this.sources);
+    if (queue == this.queue)
+      return;
+    if (!this.subscribers) {
+      queue || !this.queue || unsubscribeAll(this);
+    }
     if (this.queue) {
       if (this.queue.has(this))
         queue?.add(this);
       this.queue.delete(this);
-      queue || this.ctx.job?.restart();
     } else if (queue) {
       queue.add(this);
-      this.subscribers || subscribeAll(this.sources);
+      this.subscribers || subscribeAll(this);
     }
     this.queue = queue;
   }
   subscribe(sub) {
-    if (!this.subscribers) {
-      this.queue || subscribeAll(this.sources);
-      if ((this.flags & 320 /* Demand */) === 64 /* Stream */)
-        this.updateDemand();
+    if (!this.subscribers && !this.queue) {
+      subscribeAll(this);
     }
     if (this.subscribers !== sub && !sub.pT) {
       sub.nT = this.subscribers;
@@ -313,10 +383,8 @@ class Cell {
     if (this.subscribers === sub)
       this.subscribers = sub.nT;
     sub.nT = sub.pT = void 0;
-    if (!this.subscribers) {
-      this.queue || unsubscribeAll(this.sources);
-      if ((this.flags & 320 /* Demand */) === 64 /* Stream */)
-        this.updateDemand();
+    if (!this.subscribers && !this.queue) {
+      unsubscribeAll(this);
     }
   }
   static mkValue(val) {
@@ -326,22 +394,32 @@ class Cell {
     cell.lastChanged = timestamp;
     return cell;
   }
+  isObserved() {
+    return !!((this.flags |= 64 /* Stateful */) & 1 /* Observed */);
+  }
+  getJob() {
+    this.flags |= 64 /* Stateful */;
+    return this.ctx.job ||= makeJob();
+  }
   updateDemand() {
-    this.flags |= 256 /* Demanded */;
-    defer(streamtrackers.get(this));
+    demandChanges.delete(this);
+    if (monitors.has(this)) {
+      monitors.get(this)();
+    } else if (this.flags & 1 /* Observed */) {
+      this.shouldWrite(true);
+    } else {
+      this.ctx.job?.restart();
+    }
   }
   static mkStream(src, val) {
     const cell = this.mkValue(val);
-    cell.flags |= 64 /* Stream */;
+    cell.flags |= 64 /* Stateful */;
     const ctx = makeCtx();
     const write = (v) => {
       cell.setValue(v, false);
     };
     let job;
-    streamtrackers.set(cell, () => {
-      if (!(cell.flags & 256 /* Demanded */))
-        return;
-      cell.flags &= ~256 /* Demanded */;
+    monitors.set(cell, () => {
       if (!cell.subscribers) {
         write(val);
         job?.end();
@@ -388,23 +466,30 @@ class Cell {
     return cell;
   }
   static mkRule(fn, q) {
-    const cell = new Cell(), outer = getJob(), job = makeJob(), stop = cell.stop.bind(cell);
-    outer === detached || ruleStops.set(cell, outer.release(stop));
-    cell.compute = () => {
+    const outer = getJob(), cell = Cell.mkCached(() => {
       try {
-        job.restart().must(fn(stop));
+        const cleanup = fn();
+        if (cleanup)
+          (cell.ctx.job || cell.getJob()).must(cleanup);
         cell.lastChanged = timestamp;
       } catch (e) {
-        stop();
+        cell.stop();
         throw e;
       }
-    };
-    cell.ctx = makeCtx(job, cell);
-    cell.flags = 4 /* Compute */;
+    }), stop = cell.stop.bind(cell);
+    outer === detached || ruleStops.set(cell, outer.release(stop));
     cell.setQ(q);
     return stop;
   }
 }
+function unchangedIf(newVal, equals = arrayEq) {
+  const { cell } = current;
+  if (cell) {
+    return cell.flags & 16 /* Error */ || !equals(cell.value, newVal) ? newVal : cell.value;
+  } else {
+    throw new Error("unchangedIf() must be called from a reactive expression");
+  }
+}
 
 class RF extends CallableObject {
   constructor(q) {
@@ -477,15 +562,15 @@ class SignalImpl extends CallableObject {
   *"uneventful.next"() {
     return yield (r) => {
       let seen = false, res;
-      rule((stop) => {
+      rule(() => {
         try {
           res = this();
         } catch (e) {
-          stop();
+          rule.stop();
           defer(reject.bind(null, r, e));
         }
         if (seen) {
-          stop();
+          rule.stop();
           defer(resolve.bind(null, r, res));
         }
         seen = true;
@@ -503,15 +588,15 @@ class SignalImpl extends CallableObject {
       }
       if (res)
         return resolve(r, res);
-      rule((stop) => {
+      rule(() => {
         try {
           res = this();
         } catch (e) {
-          stop();
+          rule.stop();
           defer(reject.bind(null, r, e));
         }
         if (res) {
-          stop();
+          rule.stop();
           defer(resolve.bind(null, r, res));
         }
       });
@@ -586,5 +671,5 @@ function waitTruthy(job, v) {
   v && job.return(v);
 }
 
-export { CircularDependency, ConfigurableImpl, SignalImpl, WritableImpl, WriteConflict, action, cached, peek, rule, runRules, until, value };
+export { CircularDependency, ConfigurableImpl, SignalImpl, WritableImpl, WriteConflict, action, cached, peek, rule, runRules, unchangedIf, until, value };
 //# sourceMappingURL=signals.mjs.map