uneventful 0.0.11 → 0.0.13

package/dist/signals.mjs

@@ -1,527 +1,8 @@
-import { F as pushCtx, G as popCtx, w as makeJob, c as root, f as isError, e as markHandled, g as getJob, x as detached, k as currentCell, o as reject, b as resolve } from './jobutils-Dvu-e99o.mjs';
-import { b as backpressure, I as IsStream, a as callOrWait } from './call-or-wait-EzXJX5Dq.mjs';
-import { e as batch, f as arrayEq, d as defer, c as apply, s as setMap, C as CallableObject } from './utils-cyEhnyp7.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 {
-}
-var timestamp = 1;
-const fntrackers = /* @__PURE__ */ new WeakMap();
-const obtrackers = /* @__PURE__ */ new WeakMap();
-const monitors = /* @__PURE__ */ new WeakMap();
-const staleStreams = batch((q) => {
-  for (const cell of q)
-    if (!cell.subscribers) {
-      ++timestamp;
-      break;
-    }
-  q.clear();
-});
-const demandChanges = batch((q) => {
-  for (const cell of q)
-    cell.updateDemand();
-});
-const dirtyStack = [];
-function markDependentsDirty(cell) {
-  const latestSource = cell.latestSource = timestamp;
-  for (; cell; cell = dirtyStack.pop()) {
-    for (let sub = cell.subscribers; sub; sub = sub.nT) {
-      const tgt = sub.tgt;
-      if (tgt.latestSource >= latestSource)
-        continue;
-      tgt.latestSource = latestSource;
-      tgt.queue?.add(tgt);
-      if (tgt.subscribers)
-        dirtyStack.push(tgt);
-    }
-  }
-}
-function returnValue() {
-  return this.value;
-}
-function throwValue() {
-  throw this.value;
-}
-const notCaughtUp = [];
-var freesubs;
-function mksub(source, target) {
-  let sub = freesubs;
-  if (sub) {
-    freesubs = sub.old;
-    sub.src = source;
-    sub.nS = void 0;
-    sub.pS = target.sources;
-    sub.tgt = target;
-    sub.nT = sub.pT = void 0;
-    sub.ts = source.lastChanged;
-    sub.old = source.adding;
-  } else
-    sub = {
-      src: source,
-      nS: void 0,
-      pS: target.sources,
-      tgt: target,
-      nT: void 0,
-      pT: void 0,
-      ts: source.lastChanged,
-      old: source.adding
-    };
-  if (target.sources)
-    target.sources.nS = sub;
-  target.sources = sub;
-  source.adding = sub;
-  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)
-    sub.nS.pS = sub.pS;
-  if (sub.pS)
-    sub.pS.nS = sub.nS;
-  sub.src = sub.tgt = sub.nS = sub.pS = sub.nT = sub.pT = void 0;
-  sub.old = freesubs;
-  freesubs = sub;
-}
-function subscribeAll(c) {
-  for (let s = firstSource(c); s; s = s.nS)
-    s.src.subscribe(s);
-  toggleDemand(c);
-}
-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;
-  return s;
-}
-function toggleDemand(c) {
-  if (((c.flags ^= 1 /* Observed */) & 64 /* Stateful */) === 64 /* Stateful */) {
-    demandChanges.has(c) ? demandChanges.delete(c) : demandChanges.add(c);
-  }
-}
-let dummySource;
-class Cell {
-  constructor() {
-    this.value = void 0;
-    // the value
-    this.validThrough = 0;
-    // timestamp of most recent validation or recalculation
-    this.lastChanged = 0;
-    // timestamp of last value change
-    this.latestSource = timestamp;
-    // max lastChanged of this cell or any ancestor source
-    this.flags = 0;
-    this.job = void 0;
-    /** The subscription being added during the current calculation - used for uniqueness */
-    this.adding = void 0;
-    /** Linked list of sources */
-    this.sources = void 0;
-    /** Linked list of targets */
-    this.subscribers = void 0;
-    this.queue = void 0;
-    /**
-     * The computation to be performed (if {@link Is.Compute}) or the
-     * setup/teardown for {@link Is.Stateful}.
-     */
-    this.compute = returnValue;
-  }
-  stream(sink, _conn, inlet) {
-    let lastValue = sentinel;
-    Cell.mkRule(() => {
-      const val = this.getValue();
-      if (val !== lastValue) {
-        pushCtx();
-        try {
-          sink(lastValue = val);
-        } finally {
-          popCtx();
-        }
-      }
-    }, inlet ? ruleQueue(backpressure(inlet)) : defaultQ);
-    return IsStream;
-  }
-  getValue() {
-    if (arguments.length)
-      return apply(this.stream, this, arguments);
-    const dep = currentCell;
-    if (dep && this.flags & 132 /* Variable */ && (dep.flags & 8 /* Peeking */) === 0) {
-      if (this.flags & 32 /* Running */)
-        throw new CircularDependency("Cached function dependency cycle");
-      let s = this.adding;
-      if (!s || s.tgt !== dep) {
-        mksub(this, dep);
-        s = this.adding;
-      } else {
-        if (s.ts === -1) {
-          s.ts = this.lastChanged;
-          if (s.nS) {
-            s.nS.pS = s.pS;
-            if (s.pS)
-              s.pS.nS = s.nS;
-            s.nS = void 0;
-            s.pS = dep.sources;
-            dep.sources.nS = s;
-            dep.sources = s;
-          }
-        }
-      }
-      this.catchUp();
-      if (this.adding === s)
-        s.ts = this.lastChanged;
-    } else
-      this.catchUp();
-    if (this.flags & 16 /* Error */)
-      throw this.value;
-    return this.value;
-  }
-  shouldWrite(changed) {
-    const cell = currentCell || currentRule;
-    if (cell) {
-      if (!cell.queue)
-        throw new WriteConflict("Side-effects not allowed outside rules");
-      if (this.adding && this.adding.tgt === cell)
-        throw new CircularDependency("Can't update direct dependency");
-      if (this.validThrough === timestamp || this.hasBeenRead())
-        throw new WriteConflict("Value already used");
-    } else if (changed) {
-      if (this.validThrough === timestamp || notCaughtUp.length) {
-        ++timestamp;
-        notCaughtUp.length = 0;
-      }
-    } else {
-      return false;
-    }
-    this.lastChanged === timestamp || markDependentsDirty(this);
-    if (this.sources)
-      this.sources.ts = 0;
-    return true;
-  }
-  setValue(val, isErr) {
-    if (this.shouldWrite(val !== this.value || isErr !== !!(this.flags & 16 /* Error */))) {
-      this.value = val;
-      this.lastChanged = timestamp;
-      this.flags = isErr ? this.flags | 16 /* Error */ : this.flags & ~16 /* Error */;
-    }
-    this.compute = isErr ? throwValue : returnValue;
-  }
-  setCalc(compute) {
-    if (this.shouldWrite(compute !== this.compute)) {
-      this.flags |= 4 /* Compute */;
-      this.compute = compute;
-    }
-  }
-  hasBeenRead() {
-    if (notCaughtUp.length) {
-      for (const cell of notCaughtUp)
-        cell.catchUp();
-      notCaughtUp.length = 0;
-    }
-    return this.validThrough === timestamp;
-  }
-  catchUp() {
-    const { validThrough } = this;
-    if (validThrough === timestamp)
-      return;
-    this.validThrough = timestamp;
-    if (!(this.flags & 4 /* Compute */)) {
-      if (this.flags & 256 /* Stream */ && !this.subscribers) {
-        this.lastChanged = timestamp;
-        staleStreams.add(this);
-      }
-      return;
-    }
-    if (this.sources) {
-      for (let sub = this.sources; sub; sub = sub.nS) {
-        const s = sub.src;
-        if (sub.ts !== s.lastChanged)
-          return this.doRecalc();
-        if (s.subscribers && s.latestSource <= validThrough)
-          continue;
-        s.catchUp();
-        if (s.lastChanged > validThrough) {
-          return this.doRecalc();
-        }
-      }
-      for (let sub = this.sources; sub; sub = sub.nS) {
-        if (sub.src.validThrough !== timestamp)
-          notCaughtUp.push(sub.src);
-      }
-    } else
-      return this.doRecalc();
-  }
-  doRecalc() {
-    pushCtx(this.job, this);
-    if (this.flags & 64 /* Stateful */) {
-      this.job?.restart();
-    }
-    for (let sub = this.sources; sub; sub = sub.nS) {
-      sub.ts = -1;
-      sub.old = sub.src.adding;
-      sub.src.adding = sub;
-      this.sources = sub;
-    }
-    this.flags |= 32 /* Running */;
-    try {
-      try {
-        const future = this.compute();
-        if (future !== this.value || !this.lastChanged || this.flags & 16 /* Error */) {
-          this.value = future;
-          this.lastChanged = timestamp;
-        }
-        this.flags &= ~16 /* Error */;
-      } catch (e) {
-        this.flags |= 16 /* Error */;
-        this.value = e;
-        this.lastChanged = timestamp;
-        if (currentRule === this)
-          throw e;
-      }
-    } finally {
-      this.flags &= ~32 /* Running */;
-      if (this.flags & 64 /* Stateful */) {
-        demandChanges.delete(this);
-        if (this.flags & (16 /* Error */ | 2 /* Stopped */)) {
-          this.flags &= ~2 /* Stopped */;
-          this.job?.restart();
-        } else if (this.flags & 1 /* Observed */) ; else {
-          this.job?.restart();
-        }
-      }
-      popCtx();
-      let head;
-      for (let sub = this.sources; sub; ) {
-        const pS = sub.pS;
-        sub.src.adding = sub.old;
-        sub.old = void 0;
-        if (sub.ts === -1)
-          delsub(sub);
-        else
-          head = sub;
-        sub = pS;
-      }
-      (this.sources = head) || this.becomeConstant();
-    }
-  }
-  becomeConstant() {
-    if (this.flags & 32 /* Running */)
-      return;
-    if (this.flags & 64 /* Stateful */) {
-      mksub(dummySource ||= Cell.mkValue(null), this);
-      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) {
-    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);
-    } else if (queue) {
-      queue.add(this);
-      this.subscribers || subscribeAll(this);
-    }
-    this.queue = queue;
-  }
-  subscribe(sub) {
-    if (!this.subscribers && !this.queue) {
-      subscribeAll(this);
-    }
-    if (this.subscribers !== sub && !sub.pT) {
-      sub.nT = this.subscribers;
-      if (this.subscribers)
-        this.subscribers.pT = sub;
-      this.subscribers = sub;
-    }
-  }
-  unsubscribe(sub) {
-    if (sub.nT)
-      sub.nT.pT = sub.pT;
-    if (sub.pT)
-      sub.pT.nT = sub.nT;
-    if (this.subscribers === sub)
-      this.subscribers = sub.nT;
-    sub.nT = sub.pT = void 0;
-    if (!this.subscribers && !this.queue) {
-      unsubscribeAll(this);
-    }
-  }
-  static mkValue(val) {
-    const cell = new Cell();
-    cell.flags = 128 /* Mutable */;
-    cell.value = val;
-    cell.lastChanged = timestamp;
-    return cell;
-  }
-  isObserved() {
-    if (this.flags & 8 /* Peeking */)
-      return false;
-    return !!((this.flags |= 64 /* Stateful */) & 1 /* Observed */);
-  }
-  getJob() {
-    if (this.job)
-      return this.job;
-    this.flags |= 64 /* Stateful */;
-    return this.job = makeJob();
-  }
-  updateDemand() {
-    demandChanges.delete(this);
-    if (monitors.has(this)) {
-      monitors.get(this)();
-    } else if (this.flags & 1 /* Observed */) {
-      this.shouldWrite(true);
-    } else {
-      this.job?.restart();
-    }
-  }
-  static mkStream(src, val) {
-    const cell = this.mkValue(val);
-    cell.flags |= 64 /* Stateful */ | 256 /* Stream */;
-    const write = (v) => {
-      cell.setValue(v, false);
-    };
-    let job;
-    monitors.set(cell, () => {
-      if (!cell.subscribers) {
-        write(val);
-        job?.end();
-        return;
-      }
-      if (job)
-        return;
-      job = makeJob(root).do((r) => {
-        if (isError(r)) {
-          cell.setValue(markHandled(r), true);
-        } else {
-          cell.setValue(val, false);
-        }
-        job = void 0;
-      });
-      pushCtx(job);
-      try {
-        src(write, job);
-      } catch (e) {
-        job.end();
-        root.asyncThrow(e);
-      } finally {
-        popCtx();
-      }
-    });
-    return cell;
-  }
-  peek(fn, thisArg, args) {
-    if (this.flags & 8 /* Peeking */)
-      return apply(fn, thisArg, args);
-    this.flags |= 8 /* Peeking */;
-    try {
-      return apply(fn, thisArg, args);
-    } finally {
-      this.flags &= ~8 /* Peeking */;
-    }
-  }
-  recalcWhen(fnOrKey, fn) {
-    if (this.flags & 8 /* Peeking */)
-      return;
-    let trackers = fn ? obtrackers.get(fn) || setMap(obtrackers, fn, /* @__PURE__ */ new WeakMap()) : fntrackers;
-    let signal = trackers.get(fnOrKey);
-    if (!signal) {
-      const src = fn ? fn(fnOrKey) : fnOrKey;
-      let ct = 0;
-      const c = Cell.mkStream((s) => (src(() => s(++ct)), IsStream), ct);
-      trackers.set(fnOrKey, signal = c.getValue.bind(c));
-    }
-    signal();
-  }
-  static mkCached(compute) {
-    const cell = new Cell();
-    cell.compute = compute;
-    cell.flags = 4 /* Compute */;
-    return cell;
-  }
-  static mkRule(fn, q) {
-    const outer = getJob(), cell = Cell.mkCached(() => {
-      try {
-        const cleanup = fn();
-        if (cleanup)
-          (cell.job || cell.getJob()).must(cleanup);
-      } catch (e) {
-        cell.stop();
-        throw e;
-      }
-    }), stop = cell.stop.bind(cell);
-    outer === detached || ruleStops.set(cell, outer.release(stop));
-    cell.flags |= 64 /* Stateful */;
-    cell.setQ(q);
-    return stop;
-  }
-}
-function unchangedIf(newVal, equals = arrayEq) {
-  const cell = currentCell;
-  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");
-  }
-}
+import { d as root, o as currentCell, g as getJob, m as must, L as currentJob, w as reject, b as resolve } from './jobutils-O9tOTNKC.mjs';
+import { C as Cell, r as ruleQueue, d as defaultQ, c as currentRule, p as perSignal, g as getCell } from './hooks-BnMYHRlM.mjs';
+export { a as CircularDependency, W as WriteConflict } from './hooks-BnMYHRlM.mjs';
+import { d as defer, C as CallableObject, c as apply, s as setMap, b as decorateMethod, i as isFunction, f as isPlainFunction, g as arrayEq } from './utils-BgqyDPjA.mjs';
+import { c as callOrWait } from './call-or-wait-CvOF0pao.mjs';
 
 class RF extends CallableObject {
   constructor(q) {
@@ -549,9 +30,6 @@ class RF extends CallableObject {
   factory(scheduleFn) {
     return factories.get(scheduleFn) || setMap(factories, scheduleFn, new RF(ruleQueue(scheduleFn)));
   }
-  detached(fn) {
-    return detached.run(this, fn);
-  }
   root(fn) {
     return root.run(this, fn);
   }
@@ -568,6 +46,75 @@ function runRules(scheduleFn) {
   (scheduleFn ? ruleQueue(scheduleFn) : defaultQ).flush();
 }
 
+function sosSize(set) {
+  return set ? set instanceof Set ? set.size : 1 : 0;
+}
+function sosAdd(set, item) {
+  return set ? set instanceof Set ? (set.add(item), set) : /* @__PURE__ */ new Set([set, item]) : item;
+}
+function sosDel(set, item) {
+  if (set !== item)
+    return set instanceof Set ? (set.delete(item), set) : set;
+  return void 0;
+}
+function sosHas(set, item) {
+  return set === item || set instanceof Set && set.has(item);
+}
+
+function fn(f, ...args) {
+  if (args.length) {
+    return decorateMethod((f2) => {
+      const map = /* @__PURE__ */ new WeakMap();
+      return function() {
+        return (map.get(this) || setMap(map, this, Cell.mkCached(f2.bind(this)))).getValue();
+      };
+    }, f, ...args);
+  } else if (!isFunction(f)) {
+    return perSignal(fn, f, "fn``() ");
+  } else if (f.length) {
+    const map = /* @__PURE__ */ new WeakMap();
+    return (ob) => (map.get(ob) || setMap(map, ob, Cell.mkCached(f(ob)))).getValue();
+  }
+  return cached(f);
+}
+function fx(f, ...args) {
+  if (args.length) {
+    return decorateMethod((method) => {
+      const m = fx((ob) => method.bind(ob));
+      return function() {
+        m(this);
+      };
+    }, f, ...args);
+  } else if (!isFunction(f)) {
+    return perSignal(fx, f, "fx``() ");
+  } else if (f.length) {
+    const map = /* @__PURE__ */ new WeakMap();
+    return (ob) => (map.get(ob) || setMap(map, ob, fx(f(ob))))();
+  } else if (!isPlainFunction(f)) {
+    throw new Error("fx() bodies must be plain functions, not signals, generators, or async");
+  } else {
+    let jobs, cell = Cell.mkCached(f);
+    return () => {
+      if (currentCell) {
+        if (currentCell.isObserved())
+          cell.getValue();
+      } else {
+        if (!sosHas(jobs, getJob())) {
+          const job = currentJob;
+          jobs = sosAdd(jobs, job);
+          sosSize(jobs) > 1 || (cell.setQ(defaultQ), defaultQ.delete(cell));
+          must(() => {
+            jobs = sosDel(jobs, job);
+            if (!sosSize(jobs))
+              cell.setQ();
+          });
+        }
+        cell.catchUp();
+      }
+    };
+  }
+}
+
 class SignalImpl extends CallableObject {
   constructor(_c) {
     super(_c.getValue.bind(_c));
@@ -685,6 +232,17 @@ function action(fn, _ctx, desc) {
     return currentCell ? currentCell.peek(fn, this, args) : apply(fn, this, args);
   };
 }
+function stable(equals, newVal) {
+  return getCell("stabilizers ").unchangedIf(newVal, equals);
+}
+function unchangedIf(newVal, equals = arrayEq) {
+  return stable(equals, newVal);
+}
+function stabilizer(equals) {
+  return stable.bind(null, equals);
+}
+const stableArray = /* @__PURE__ */ stabilizer(arrayEq);
+const stableJSON = /* @__PURE__ */ stabilizer((a, b) => JSON.stringify(a) === JSON.stringify(b));
 function until(source) {
   return callOrWait(source, "uneventful.until", waitTruthy, recache);
 }
@@ -695,4 +253,4 @@ function waitTruthy(job, v) {
   v && job.return(v);
 }
 
-export { CircularDependency, ConfigurableImpl, SignalImpl, WritableImpl, WriteConflict, action, cached, peek, rule, runRules, unchangedIf, until, value };
+export { ConfigurableImpl, SignalImpl, WritableImpl, action, cached, fn, fx, peek, rule, runRules, stabilizer, stable, stableArray, stableJSON, unchangedIf, until, value };

package/dist/{sinks-5TuxCRtX.d.ts → sinks-B_LfTZgF.d.ts}

@@ -1,4 +1,4 @@
-import { h as Suspend, a as Stream, Y as Yielding, b as Sink, I as Inlet, K as Connection, i as RecalcSource } from './types-N2ua11te.js';
+import { h as Suspend, a as Stream, Y as Yielding, b as Sink, I as Inlet, K as Connection, i as RecalcSource } from './types-pElgImr7.js';
 
 /**
  * The result type returned from calls to {@link Each}.next()