uneventful 0.0.12 → 0.0.13

package/dist/call-or-wait-CvOF0pao.mjs

@@ -0,0 +1,22 @@
+import { s as start, j as connect, p as isValue, h as isError, f as markHandled } from './jobutils-O9tOTNKC.mjs';
+import { i as isFunction } from './utils-BgqyDPjA.mjs';
+
+function callOrWait(source, method, handler, noArgs) {
+  if (source && isFunction(source[method]))
+    return source[method]();
+  if (!isFunction(source))
+    mustBeSourceOrSignal();
+  return (source.length === 0 ? noArgs(source) : false) || start((job) => {
+    connect(source, (v) => handler(job, v)).do((r) => {
+      if (isValue(r))
+        job.throw(new Error("Stream ended"));
+      else if (isError(r))
+        job.throw(markHandled(r));
+    });
+  });
+}
+function mustBeSourceOrSignal() {
+  throw new TypeError("not a source or signal");
+}
+
+export { callOrWait as c, mustBeSourceOrSignal as m };

package/dist/ext.d.ts

@@ -1,4 +1,4 @@
-import { P as PlainFunction } from './types-N2ua11te.js';
+import { P as PlainFunction } from './types-pElgImr7.js';
 
 /**
  * This module provides helpers for creating *extensions*: a way of extending
@@ -15,7 +15,6 @@ import { P as PlainFunction } from './types-N2ua11te.js';
  *
  * @module uneventful/ext
  *
- * @experimental
  * @disableGroups
  * @summary Tools for extending objects with extra state and behavior, without
  * directly modifying them.
@@ -100,7 +99,7 @@ declare function ext<Target extends WeakKey, ExtType extends Object>(factory: (t
  * arguments (minus an initial `target` argument).
  */
 declare function method<Target extends object, Method extends PlainFunction>(factory: (tgt: Target, map: WeakMap<Target, Method>) => Method, map?: WeakMap<Target, Method>): (tgt: Target, ...args: Parameters<Method>) => ReturnType<Method>;
-/** Helper types for working with {@link Ext} Subclasses */
+/** Helper types for working with {@link Ext} Subclasses @experimental */
 declare namespace Ext {
     /** Get the target type of an {@link Ext} subclass constructor */
     type Target<T extends Ext.Class> = InstanceType<T>["of"];
@@ -144,6 +143,8 @@ declare namespace Ext {
  *
  * Instance and static members you can override to customize extension creation,
  * deletion, target and return types.
+ *
+ * @experimental
  */
 declare abstract class Ext<Target extends WeakKey = WeakKey> {
     /**
@@ -205,7 +206,7 @@ declare abstract class Ext<Target extends WeakKey = WeakKey> {
      *
      *     __new__(tgt: SomeType): Job<this> {
      *         const ext = this.__inst__(tgt);
-     *         map.set(tgt, root.start(ext.setup()) as Ext.Type<Class>);
+     *         return start(this.__inst__(tgt).setup())
      *     }
      * }
      * ```

package/dist/ext.mjs

@@ -1,4 +1,4 @@
-import { s as setMap } from './utils-cyEhnyp7.mjs';
+import { s as setMap } from './utils-BgqyDPjA.mjs';
 
 function ext(factory, map = /* @__PURE__ */ new WeakMap()) {
   return (tgt) => map.has(tgt) ? map.get(tgt) : setMap(map, tgt, factory(tgt, map));
@@ -73,7 +73,7 @@ class Ext {
    *
    *     __new__(tgt: SomeType): Job<this> {
    *         const ext = this.__inst__(tgt);
-   *         map.set(tgt, root.start(ext.setup()) as Ext.Type<Class>);
+   *         return start(this.__inst__(tgt).setup())
    *     }
    * }
    * ```

package/dist/hooks-BnMYHRlM.mjs

@@ -0,0 +1,583 @@
+import { M as pushCtx, N as popCtx, c as backpressure, I as IsStream, _ as _Job, d as root, h as isError, f as markHandled, g as getJob, o as currentCell } from './jobutils-O9tOTNKC.mjs';
+import { h as batch, d as defer, c as apply, s as setMap } from './utils-BgqyDPjA.mjs';
+
+const ruleQueues = /* @__PURE__ */ new WeakMap();
+function ruleQueue(scheduleFn = defer) {
+  ruleQueues.has(scheduleFn) || ruleQueues.set(scheduleFn, batch(runRules, scheduleFn));
+  return ruleQueues.get(scheduleFn);
+}
+var currentRule;
+const ruleStops = /* @__PURE__ */ new WeakMap();
+const defaultQ = /* @__PURE__ */ ruleQueue(defer);
+var currentQueue;
+function runRules(q) {
+  if (currentQueue)
+    return;
+  while (q.size) {
+    currentQueue = this;
+    try {
+      for (currentRule of q) {
+        currentRule.catchUp();
+        q.delete(currentRule);
+      }
+    } finally {
+      currentQueue = currentRule = unset;
+    }
+    demandChanges.flush();
+  }
+}
+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;
+const unset = void 0;
+function mksub(source, target) {
+  let sub = freesubs;
+  if (sub) {
+    freesubs = sub.old;
+    sub.src = source;
+    sub.nS = unset;
+    sub.pS = target.sources;
+    sub.tgt = target;
+    sub.nT = sub.pT = unset;
+    sub.ts = source.lastChanged;
+    sub.old = source.adding;
+  } else
+    sub = {
+      src: source,
+      nS: unset,
+      pS: target.sources,
+      tgt: target,
+      nT: unset,
+      pT: unset,
+      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 = unset;
+  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 = unset;
+    /** Linked list of sources */
+    this.sources = unset;
+    /** Linked list of targets */
+    this.subscribers = unset;
+    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 = unset;
+            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(void 0, 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 = unset;
+      for (let sub = this.sources; sub; ) {
+        const pS = sub.pS;
+        sub.src.adding = sub.old;
+        sub.old = unset;
+        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();
+    if (this.flags & 32 /* Running */) {
+      this.flags |= 2 /* Stopped */;
+    } else
+      this.updateDemand();
+    ruleStops.get(this)?.();
+  }
+  setQ(queue) {
+    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 = unset;
+    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.isObserved())
+      throw new Error("Job API used in unobserved signal or peek()");
+    if (this.job)
+      return this.job;
+    this.flags |= 64 /* Stateful */;
+    return this.job = new _Job();
+  }
+  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 = new _Job(root).do((r) => {
+        if (isError(r)) {
+          cell.setValue(markHandled(r), true);
+        } else {
+          cell.setValue(val, false);
+        }
+        job = unset;
+      });
+      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 */;
+    }
+  }
+  unchangedIf(newVal, equals) {
+    return this.flags & 16 /* Error */ || !equals(this.value, newVal) ? newVal : this.value;
+  }
+  recalcWhen(fnOrKey, fn = unset) {
+    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);
+    ruleStops.set(cell, outer.release(stop));
+    cell.flags |= 64 /* Stateful */;
+    cell.setQ(q);
+    return stop;
+  }
+}
+function getCell(f = "") {
+  if (!currentCell || currentCell.flags & 8 /* Peeking */)
+    throw new Error(
+      `${f}must be called from a reactive expression`
+    );
+  return currentCell;
+}
+
+const allHooks = /* @__PURE__ */ new WeakMap();
+function indexOf(hooks, site) {
+  if (hooks[0 /* CURRENT */] === site)
+    return hooks[1 /* OFFSET */];
+  let pos = hooks.indexOf(site, hooks[1 /* OFFSET */]);
+  if (pos < 0 && hooks[1 /* OFFSET */] > 2 /* FIRST */)
+    pos = hooks.indexOf(site, 2 /* FIRST */);
+  hooks[0 /* CURRENT */] = site;
+  return hooks[1 /* OFFSET */] = pos < 0 ? hooks.length : pos;
+}
+function getHooks(ctx = currentCell || getCell("hook-using functions ")) {
+  return allHooks.get(ctx) || setMap(allHooks, ctx, [null, 2 /* FIRST */]);
+}
+function findOrCreateMemos(hooks, site, size = 0) {
+  if (indexOf(hooks, site) < hooks.length)
+    return true;
+  if (size) {
+    hooks.push(site);
+    hooks.length += size;
+  }
+  return false;
+}
+function getMemo(hooks, offset) {
+  return hooks[hooks[1 /* OFFSET */] + offset];
+}
+function setMemo(hooks, offset, val) {
+  return hooks[hooks[1 /* OFFSET */] + offset] = val;
+}
+function perSignal(func, site, name) {
+  const hooks = getHooks(currentCell || getCell(name));
+  return findOrCreateMemos(hooks, site) ? (
+    // Fast path - return a no-op function with the constant result
+    // (avoids any dynamic memory allocation)
+    getMemo(hooks, 1)
+  ) : (
+    // Slow path - needs to receive args to call the function,
+    // and then save the closure for future fast path calls
+    (...args) => {
+      const hooks2 = getHooks(currentCell || getCell(name));
+      if (findOrCreateMemos(hooks2, site, 1)) {
+        return getMemo(hooks2, 1)();
+      } else {
+        const result = func(...args);
+        setMemo(hooks2, 1, () => result);
+        return result;
+      }
+    }
+  );
+}
+
+export { Cell as C, WriteConflict as W, CircularDependency as a, currentRule as c, defaultQ as d, getCell as g, perSignal as p, ruleQueue as r };