uneventful 0.0.4 → 0.0.6

package/dist/signals.mjs

@@ -0,0 +1,590 @@
+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';
+
+class WriteConflict extends Error {
+}
+class CircularDependency extends Error {
+}
+var timestamp = 1;
+const fntrackers = /* @__PURE__ */ new WeakMap();
+const obtrackers = /* @__PURE__ */ new WeakMap();
+const streamtrackers = /* @__PURE__ */ new WeakMap();
+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.subscribers || target.queue)
+    source.subscribe(sub);
+}
+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(s) {
+  if (s)
+    while (s.pS)
+      s = s.pS;
+  else
+    return;
+  for (; s; s = s.nS)
+    s.src.subscribe(s);
+}
+function unsubscribeAll(s) {
+  if (s)
+    while (s.pS)
+      s = s.pS;
+  else
+    return;
+  for (; s; s = s.nS)
+    s.src.unsubscribe(s);
+}
+const sentinel = {};
+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.ctx = 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.Stream}.
+     */
+    this.compute = returnValue;
+  }
+  stream(sink, _conn, inlet) {
+    let lastValue = sentinel;
+    Cell.mkRule(() => {
+      const val = this.getValue();
+      if (val !== lastValue) {
+        const old = swapCtx(nullCtx);
+        try {
+          sink(lastValue = val);
+        } finally {
+          swapCtx(old);
+        }
+      }
+    }, inlet ? ruleQueue(backpressure(inlet)) : defaultQ);
+    return IsStream;
+  }
+  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 */)
+        throw new CircularDependency("Cached function dependency cycle");
+      let s = this.adding;
+      if (!s || s.tgt !== dep) {
+        mksub(this, dep);
+      } 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;
+          }
+        }
+      }
+    }
+    if (this.flags & 16 /* Error */)
+      throw this.value;
+    return this.value;
+  }
+  shouldWrite(changed) {
+    const cell = current.cell || 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;
+      this.ctx ||= makeCtx(null, this);
+    }
+  }
+  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 */))
+      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() {
+    const oldCtx = swapCtx(this.ctx);
+    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 */;
+      swapCtx(oldCtx);
+      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;
+      if (!head) {
+        this.flags &= ~4 /* Compute */;
+      }
+    }
+  }
+  stop() {
+    this.setQ(null);
+    ruleStops.get(this)?.();
+  }
+  setQ(queue = defaultQ) {
+    queue || this.subscribers || unsubscribeAll(this.sources);
+    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.queue = queue;
+  }
+  subscribe(sub) {
+    if (!this.subscribers) {
+      this.queue || subscribeAll(this.sources);
+      if ((this.flags & 320 /* Demand */) === 64 /* Stream */)
+        this.updateDemand();
+    }
+    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.sources);
+      if ((this.flags & 320 /* Demand */) === 64 /* Stream */)
+        this.updateDemand();
+    }
+  }
+  static mkValue(val) {
+    const cell = new Cell();
+    cell.flags = 128 /* Mutable */;
+    cell.value = val;
+    cell.lastChanged = timestamp;
+    return cell;
+  }
+  updateDemand() {
+    this.flags |= 256 /* Demanded */;
+    defer(streamtrackers.get(this));
+  }
+  static mkStream(src, val) {
+    const cell = this.mkValue(val);
+    cell.flags |= 64 /* Stream */;
+    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 */;
+      if (!cell.subscribers) {
+        write(val);
+        job?.end();
+        return;
+      }
+      if (job)
+        return;
+      job = ctx.job = makeJob().do((r) => {
+        if (isError(r)) {
+          cell.setValue(markHandled(r), true);
+        } else {
+          cell.setValue(val, false);
+        }
+        ctx.job = job = void 0;
+      });
+      const old = swapCtx(ctx);
+      try {
+        src(write, job);
+      } catch (e) {
+        job.end();
+        detached.asyncThrow(e);
+      } finally {
+        swapCtx(old);
+      }
+    });
+    return cell;
+  }
+  recalcWhen(fnOrKey, fn) {
+    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.ctx = makeCtx(null, cell);
+    cell.flags = 4 /* Compute */;
+    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 = () => {
+      try {
+        job.restart().must(fn(stop));
+        cell.lastChanged = timestamp;
+      } catch (e) {
+        stop();
+        throw e;
+      }
+    };
+    cell.ctx = makeCtx(job, cell);
+    cell.flags = 4 /* Compute */;
+    cell.setQ(q);
+    return stop;
+  }
+}
+
+class RF extends CallableObject {
+  constructor(q) {
+    super((fn) => Cell.mkRule(fn, q));
+  }
+  get stop() {
+    if (currentRule)
+      return currentRule.stop.bind(currentRule);
+    throw new Error("No rule active");
+  }
+  if(condition, action) {
+    const cond = Cell.mkCached(() => !!condition());
+    return this(() => cond.getValue() ? action() : void 0);
+  }
+  get method() {
+    const self = this;
+    return (fn, _ctxOrName, desc) => {
+      if (desc)
+        return void (desc.value = this.method(desc.value));
+      return function(...args) {
+        return self(() => apply(fn, this, args));
+      };
+    };
+  }
+  factory(scheduleFn) {
+    return factories.get(scheduleFn) || setMap(factories, scheduleFn, new RF(ruleQueue(scheduleFn)));
+  }
+  detached(fn) {
+    return detached.run(this, fn);
+  }
+  setScheduler(scheduleFn) {
+    if (currentRule)
+      currentRule.setQ(scheduleFn ? ruleQueue(scheduleFn) : defaultQ);
+    else
+      throw new Error("No rule active");
+  }
+}
+const factories = /* @__PURE__ */ new WeakMap();
+const rule = RF.prototype.factory(defer);
+function runRules(scheduleFn) {
+  (scheduleFn ? ruleQueue(scheduleFn) : defaultQ).flush();
+}
+
+class SignalImpl extends CallableObject {
+  constructor(_c) {
+    super(_c.getValue.bind(_c));
+    this._c = _c;
+  }
+  get value() {
+    return this();
+  }
+  valueOf() {
+    return this();
+  }
+  toString() {
+    return "" + this();
+  }
+  toJSON() {
+    return this();
+  }
+  peek() {
+    return peek(this);
+  }
+  asReadonly() {
+    return this;
+  }
+  withSet(set) {
+    return Object.assign(new WritableImpl(this._c), { set });
+  }
+  *"uneventful.next"() {
+    return yield (r) => {
+      let seen = false, res;
+      rule((stop) => {
+        try {
+          res = this();
+        } catch (e) {
+          stop();
+          defer(reject.bind(null, r, e));
+        }
+        if (seen) {
+          stop();
+          defer(resolve.bind(null, r, res));
+        }
+        seen = true;
+      });
+    };
+  }
+  *"uneventful.until"() {
+    return yield (r) => {
+      let res;
+      try {
+        res = this();
+      } catch (e) {
+        reject(r, e);
+        return;
+      }
+      if (res)
+        return resolve(r, res);
+      rule((stop) => {
+        try {
+          res = this();
+        } catch (e) {
+          stop();
+          defer(reject.bind(null, r, e));
+        }
+        if (res) {
+          stop();
+          defer(resolve.bind(null, r, res));
+        }
+      });
+    };
+  }
+}
+class WritableImpl extends SignalImpl {
+  constructor() {
+    super(...arguments);
+    this.set = (val) => {
+      this._c.setValue(val, false);
+    };
+  }
+  get value() {
+    return this();
+  }
+  set value(val) {
+    this.set(val);
+  }
+  asReadonly() {
+    return new SignalImpl(this._c);
+  }
+}
+class ConfigurableImpl extends WritableImpl {
+  setf(expr) {
+    this._c.setCalc(expr);
+    return this;
+  }
+}
+function value(val) {
+  const cell = Cell.mkValue(val);
+  return new ConfigurableImpl(cell);
+}
+function cached(compute, initVal) {
+  if (compute instanceof SignalImpl)
+    return compute;
+  return new SignalImpl(
+    compute.length ? Cell.mkStream(compute, initVal) : Cell.mkCached(compute)
+  );
+}
+function peek(fn, ...args) {
+  if (!current.cell)
+    return fn(...args);
+  const old = swapCtx(makeCtx(current.job));
+  try {
+    return fn(...args);
+  } finally {
+    freeCtx(swapCtx(old));
+  }
+}
+function action(fn, _ctx, desc) {
+  if (desc)
+    return { ...desc, value: action(desc.value) };
+  return function() {
+    if (!current.cell)
+      return apply(fn, this, arguments);
+    const old = swapCtx(makeCtx(current.job));
+    try {
+      return apply(fn, this, arguments);
+    } finally {
+      freeCtx(swapCtx(old));
+    }
+  };
+}
+function until(source) {
+  return callOrWait(source, "uneventful.until", waitTruthy, recache);
+}
+function recache(s) {
+  return until(cached(s));
+}
+function waitTruthy(job, v) {
+  v && job.return(v);
+}
+
+export { CircularDependency, ConfigurableImpl, SignalImpl, WritableImpl, WriteConflict, action, cached, peek, rule, runRules, until, value };
+//# sourceMappingURL=signals.mjs.map