uneventful 0.0.4 → 0.0.6

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

@@ -0,0 +1,773 @@
+import { isFunction, apply } from './utils.mjs';
+
+let defer = typeof queueMicrotask === "function" ? queueMicrotask : /* @__PURE__ */ ((p) => (cb) => p.then(cb))(Promise.resolve());
+
+function resolve(request, val) {
+  request("next", val);
+}
+function reject(request, reason) {
+  request("throw", void 0, reason);
+}
+function resolver(request) {
+  return request.bind(null, "next");
+}
+function rejecter(request) {
+  return request.bind(null, "throw", void 0);
+}
+function noop() {
+}
+function mkResult(op, val, err) {
+  return { op, val, err };
+}
+const CancelResult = Object.freeze(mkResult("cancel"));
+function ValueResult(val) {
+  return mkResult("next", val);
+}
+function ErrorResult(err) {
+  return mkResult("throw", void 0, err);
+}
+function isCancel(res) {
+  return res === CancelResult;
+}
+function isValue(res) {
+  return res ? res.op === "next" : false;
+}
+function isError(res) {
+  return res ? res.op === "throw" : false;
+}
+function isUnhandled(res) {
+  return isError(res) && res.val === void 0;
+}
+function isHandled(res) {
+  return isError(res) && res.val === null;
+}
+function markHandled(res) {
+  res.val = null;
+  return res.err;
+}
+function getResult(res) {
+  if (isValue(res))
+    return res.val;
+  res.op;
+  fulfillPromise(noop, (e) => {
+    throw e;
+  }, res);
+}
+function fulfillPromise(resolve2, reject2, res) {
+  if (isError(res))
+    reject2(markHandled(res));
+  else if (isCancel(res))
+    reject2(new CancelError("Job canceled"));
+  else
+    resolve2(res.val);
+}
+function propagateResult(job, res) {
+  if (!job.result())
+    fulfillPromise(job.return.bind(job), job.throw.bind(job), res);
+}
+class CancelError extends Error {
+}
+
+var current = makeCtx();
+function swapCtx(future) {
+  const now = current;
+  current = future;
+  return now;
+}
+var freelist = [];
+function makeCtx(job, cell) {
+  if (freelist && freelist.length) {
+    const s = freelist.pop();
+    s.job = job;
+    s.cell = cell;
+    return s;
+  }
+  return { job, cell };
+}
+function freeCtx(s) {
+  s.job = s.cell = null;
+  freelist.push(s);
+}
+
+const catchers = /* @__PURE__ */ new WeakMap(), defaultCatch = (e) => {
+  Promise.reject(e);
+};
+const nullCtx = makeCtx();
+const owners = /* @__PURE__ */ new WeakMap();
+
+function chain() {
+  return link(0, void 0, void 0);
+}
+function recycle(c) {
+  while (c.v)
+    unlink(c, c.n);
+  c.u = void 0;
+  unlink(c, c);
+}
+function unshift(c, v) {
+  ++c.v;
+  link(v, c.n, c);
+}
+function push(c, v) {
+  ++c.v;
+  link(v, c, c.p);
+}
+function pushCB(c, v) {
+  ++c.v;
+  return unlinker(c, link(v, c, c.p));
+}
+function isEmpty(c) {
+  return !c || c.v === 0;
+}
+function qlen(c) {
+  return c ? c.v : 0;
+}
+function pop(c) {
+  if (qlen(c))
+    return unlink(c, c.p);
+}
+class Node {
+  constructor() {
+    /** The next node (or the start node if this is a chain head) */
+    this.n = this;
+    /** The previous node (or the end node if this is a chain head) */
+    this.p = this;
+    /** The value held by the node (or the chain length if this is a chain head) */
+    this.v = void 0;
+    /** The most recently created undo callback for this node */
+    this.u = void 0;
+  }
+}
+var free;
+function link(v, n, p) {
+  let node = free;
+  if (node) {
+    free = node.n;
+    node.n = n || node;
+    node.p = p || node;
+  } else {
+    node = new Node();
+    if (n)
+      node.n = n;
+    if (p)
+      node.p = p;
+  }
+  node.v = v;
+  node.n.p = node;
+  node.p.n = node;
+  return node;
+}
+function unlink(c, node) {
+  --c.v;
+  var v = node.v, u = node.u;
+  node.n && (node.n.p = node.p);
+  node.p && (node.p.n = node.n);
+  node.u = node.v = node.p = void 0;
+  node.n = free;
+  free = node;
+  if (u)
+    u();
+  return v;
+}
+function unlinker(chain2, node) {
+  let u = node.u ||= () => {
+    if (u) {
+      if (u === node.u)
+        unlink(chain2, node);
+      u = chain2 = node = void 0;
+    }
+  };
+  return u;
+}
+
+function getJob() {
+  const { job } = current;
+  if (job)
+    return job;
+  throw new Error("No job is currently active");
+}
+function recalcJob(job) {
+  return (cb) => {
+    current.job.must(job.release(cb));
+  };
+}
+function runChain(res, cbs) {
+  while (qlen(cbs))
+    try {
+      pop(cbs)(res);
+    } catch (e) {
+      detached.asyncThrow(e);
+    }
+  cbs && recycle(cbs);
+  return void 0;
+}
+var inProcess = /* @__PURE__ */ new Set();
+class _Job {
+  constructor() {
+    this.end = () => {
+      const res = this._done ||= CancelResult, cbs = this._cbs;
+      if (!cbs && !isUnhandled(res))
+        return;
+      const ct = inProcess.size, old = swapCtx(nullCtx);
+      if (!ct)
+        inProcess.add(null);
+      if (cbs && cbs.u)
+        cbs.u = runChain(res, cbs.u);
+      inProcess.add(this);
+      if (ct) {
+        swapCtx(old);
+        return;
+      }
+      inProcess.delete(null);
+      for (const item of inProcess) {
+        if (item._cbs)
+          item._cbs = runChain(item._done, item._cbs);
+        inProcess.delete(item);
+        if (isUnhandled(item._done))
+          item.throw(markHandled(item._done));
+      }
+      swapCtx(old);
+    };
+    this._done = void 0;
+    // Chain whose .u stores a second chain for `release()` callbacks
+    this._cbs = void 0;
+  }
+  /** @internal */
+  static create(parent, stop) {
+    const job = new _Job();
+    if (parent || stop) {
+      job.must((parent ||= getJob()).release(stop || job.end));
+      owners.set(job, parent);
+    }
+    return job;
+  }
+  do(cleanup) {
+    unshift(this._chain(), cleanup);
+    return this;
+  }
+  onError(cb) {
+    return this.do((r) => {
+      if (isError(r))
+        cb(markHandled(r));
+    });
+  }
+  onValue(cb) {
+    return this.do((r) => {
+      if (isValue(r))
+        cb(r.val);
+    });
+  }
+  onCancel(cb) {
+    return this.do((r) => {
+      if (isCancel(r))
+        cb();
+    });
+  }
+  result() {
+    return this._done || current.cell?.recalcWhen(this, recalcJob) || void 0;
+  }
+  get [Symbol.toStringTag]() {
+    return "Job";
+  }
+  restart() {
+    if (!this._done && inProcess.size) {
+      const old = inProcess;
+      inProcess = /* @__PURE__ */ new Set();
+      this.end();
+      inProcess = old;
+    } else {
+      this._end(CancelResult);
+    }
+    this._done = void 0;
+    promises.delete(this);
+    return this;
+  }
+  _end(res) {
+    if (this._done)
+      throw new Error("Job already ended");
+    if (this !== detached)
+      this._done = res;
+    this.end();
+    return this;
+  }
+  throw(err) {
+    if (this._done) {
+      (owners.get(this) || detached).asyncThrow(err);
+      return this;
+    }
+    return this._end(ErrorResult(err));
+  }
+  return(val) {
+    return this._end(ValueResult(val));
+  }
+  then(onfulfilled, onrejected) {
+    return nativePromise(this).then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return nativePromise(this).catch(onrejected);
+  }
+  finally(onfinally) {
+    return nativePromise(this).finally(onfinally);
+  }
+  *[Symbol.iterator]() {
+    if (this._done) {
+      return getResult(this._done);
+    } else
+      return yield (req) => {
+        this.do((res) => fulfillPromise(resolver(req), rejecter(req), res));
+      };
+  }
+  start(fnOrCtx, fn) {
+    if (!fnOrCtx)
+      return makeJob(this);
+    let init, result;
+    if (isFunction(fn)) {
+      init = fn.bind(fnOrCtx);
+    } else if (isFunction(fnOrCtx)) {
+      init = fnOrCtx;
+    } else if (fnOrCtx instanceof _Job) {
+      return fnOrCtx;
+    } else {
+      result = fnOrCtx;
+    }
+    const job = makeJob(this);
+    try {
+      if (init)
+        result = job.run(init, job);
+      if (result != null) {
+        if (result instanceof _Job) {
+          if (result !== job)
+            result.do((res) => propagateResult(job, res));
+        } else if (isFunction(result.then)) {
+          result.then(
+            (v) => {
+              job.result() || job.return(v);
+            },
+            (e) => {
+              job.result() || job.throw(e);
+            }
+          );
+          return job;
+        } else if (isFunction(result[Symbol.iterator]) && typeof result !== "string") {
+          job.run(runGen, result, job);
+        } else if (isFunction(result)) {
+          job.must(result);
+        } else {
+          throw new TypeError("Invalid value/return for start()");
+        }
+      }
+      return job;
+    } catch (e) {
+      job.end();
+      throw e;
+    }
+  }
+  connect(src, sink, inlet) {
+    return this.start((job) => void src(sink, job, inlet));
+  }
+  run(fn, ...args) {
+    const old = swapCtx(makeCtx(this));
+    try {
+      return fn(...args);
+    } finally {
+      freeCtx(swapCtx(old));
+    }
+  }
+  bind(fn) {
+    const job = this;
+    return function() {
+      const old = swapCtx(makeCtx(job));
+      try {
+        return apply(fn, this, arguments);
+      } finally {
+        freeCtx(swapCtx(old));
+      }
+    };
+  }
+  must(cleanup) {
+    if (isFunction(cleanup))
+      push(this._chain(), cleanup);
+    return this;
+  }
+  release(cleanup) {
+    if (this === detached)
+      return noop;
+    let cbs = this._chain();
+    if (!this._done || cbs.u)
+      cbs = cbs.u ||= chain();
+    return pushCB(cbs, cleanup);
+  }
+  asyncThrow(err) {
+    try {
+      (catchers.get(this) || this.throw).call(this, err);
+    } catch (e) {
+      if (this === detached)
+        catchers.set(this, defaultCatch);
+      else
+        catchers.delete(this);
+      const catcher = catchers.get(this) || this.throw;
+      catcher.call(this, err);
+      catcher.call(this, e);
+    }
+    return this;
+  }
+  asyncCatch(handler) {
+    if (isFunction(handler))
+      catchers.set(this, handler);
+    else if (handler === null)
+      catchers.delete(this);
+    return this;
+  }
+  _chain() {
+    if (this === detached)
+      this.end();
+    if (this._done && isEmpty(this._cbs))
+      defer(this.end);
+    return this._cbs ||= chain();
+  }
+}
+const promises = /* @__PURE__ */ new WeakMap();
+function nativePromise(job) {
+  if (!promises.has(job)) {
+    promises.set(job, new Promise((res, rej) => {
+      const toPromise = fulfillPromise.bind(null, res, rej);
+      if (job.result())
+        toPromise(job.result());
+      else
+        job.do(toPromise);
+    }));
+  }
+  return promises.get(job);
+}
+const makeJob = _Job.create;
+const detached = makeJob();
+detached.end = () => {
+  throw new Error("Can't do that with the detached job");
+};
+detached.asyncCatch(defaultCatch);
+function runGen(g, job) {
+  let it = g[Symbol.iterator](), running = true, ctx = makeCtx(job), ct = 0;
+  let done = ctx.job.release(() => {
+    job = void 0;
+    ++ct;
+    step("return", void 0);
+  });
+  defer(() => {
+    running = false;
+    step("next", void 0);
+  });
+  function step(method, arg) {
+    if (!it)
+      return;
+    if (running) {
+      return defer(step.bind(null, method, arg));
+    }
+    const old = swapCtx(ctx);
+    try {
+      running = true;
+      try {
+        for (; ; ) {
+          ++ct;
+          const { done: done2, value } = it[method](arg);
+          if (done2) {
+            job && job.return(value);
+            job = void 0;
+            break;
+          } else if (!isFunction(value)) {
+            method = "throw";
+            arg = new TypeError("Jobs must yield functions (or yield* Yielding<T>s)");
+            continue;
+          } else {
+            let called = false, returned = false, count = ct;
+            value((op, val, err) => {
+              if (called)
+                return;
+              else
+                called = true;
+              method = op;
+              arg = op === "next" ? val : err;
+              if (returned && count === ct)
+                step(op, arg);
+            });
+            returned = true;
+            if (!called)
+              return;
+          }
+        }
+      } catch (e) {
+        it = job = void 0;
+        ctx.job.throw(e);
+      }
+      it = void 0;
+      done?.();
+      done = void 0;
+    } finally {
+      swapCtx(old);
+      running = false;
+    }
+  }
+}
+
+class RunQueue {
+  constructor(sched, reap) {
+    this.sched = sched;
+    this.reap = reap;
+    this._flags = 0 /* Unset */;
+    this.q = /* @__PURE__ */ new Set();
+    this._run = () => {
+      this._flags &= ~2 /* Scheduled */;
+      this.flush();
+    };
+    /** Run all pending items */
+    this.flush = () => {
+      if (this._flags & 1 /* Running */)
+        return;
+      const { q: queue } = this;
+      if (!queue.size)
+        return;
+      this._flags |= 1 /* Running */;
+      try {
+        this.reap(queue);
+      } finally {
+        this._flags &= ~1 /* Running */;
+        !queue.size || this._flags & 2 /* Scheduled */ || this._sched();
+      }
+    };
+  }
+  /** Is this queue currently running? */
+  isRunning() {
+    return !!(this._flags & 1 /* Running */);
+  }
+  /** Is this queue currently empty? */
+  isEmpty() {
+    return !this.q.size;
+  }
+  add(subject) {
+    this.q.size || this._flags & (1 /* Running */ | 2 /* Scheduled */) || this._sched();
+    this.q.add(subject);
+  }
+  delete(subject) {
+    this.q.delete(subject);
+  }
+  has(subject) {
+    return this.q.has(subject);
+  }
+  _sched() {
+    this._flags |= 2 /* Scheduled */;
+    this.sched(this._run);
+  }
+}
+var currentRule;
+var currentQueue;
+const ruleQueues = /* @__PURE__ */ new WeakMap();
+const ruleStops = /* @__PURE__ */ new WeakMap();
+class RuleQueue extends RunQueue {
+  constructor(sched) {
+    super(sched, function(q) {
+      if (currentQueue)
+        return;
+      currentQueue = this;
+      try {
+        for (currentRule of q) {
+          currentRule.catchUp();
+          q.delete(currentRule);
+        }
+      } finally {
+        currentQueue = currentRule = void 0;
+      }
+    });
+  }
+}
+function ruleQueue(scheduleFn = defer) {
+  ruleQueues.has(scheduleFn) || ruleQueues.set(scheduleFn, new RuleQueue(scheduleFn));
+  return ruleQueues.get(scheduleFn);
+}
+const defaultQ = /* @__PURE__ */ ruleQueue(defer);
+const pulls = /* @__PURE__ */ new RunQueue(defer, (pulls2) => {
+  for (const conn of pulls2) {
+    pulls2.delete(conn);
+    conn.doPull();
+  }
+});
+
+function backpressure(inlet = defaultInlet) {
+  const job = getJob();
+  return (cb) => {
+    if (!job.result() && inlet.isOpen()) {
+      if (cb)
+        inlet.onReady(cb, job);
+      return inlet.isReady();
+    }
+    return false;
+  };
+}
+const IsStream = "uneventful/is-stream";
+function connect(src, sink, inlet) {
+  return getJob().connect(src, sink, inlet);
+}
+function throttle(job = current.job) {
+  return new _Throttle(job);
+}
+class _Throttle {
+  /** @internal */
+  constructor(_job) {
+    this._job = _job;
+    /** @internal */
+    this._callbacks = void 0;
+    this._isReady = true;
+    this._isPulling = false;
+  }
+  isOpen() {
+    return !this._job?.result();
+  }
+  /** Is the connection ready to receive data? */
+  isReady() {
+    return this.isOpen() && this._isReady;
+  }
+  onReady(cb, job) {
+    if (!this.isOpen())
+      return this;
+    const _callbacks = this._callbacks ||= /* @__PURE__ */ new Map();
+    const unlink = job.release(() => _callbacks.delete(cb));
+    if (this.isReady() && this && !_callbacks.size) {
+      pulls.add(this);
+    }
+    _callbacks.set(cb, unlink);
+    return this;
+  }
+  pause() {
+    this._isReady = false;
+    return this;
+  }
+  doPull() {
+    if (this._isPulling)
+      return;
+    const { _callbacks } = this;
+    if (!_callbacks?.size)
+      return;
+    this._isPulling = true;
+    try {
+      for (let [cb, unlink] of _callbacks) {
+        if (!this.isReady())
+          break;
+        unlink();
+        _callbacks.delete(cb);
+        cb();
+      }
+    } finally {
+      this._isPulling = false;
+    }
+  }
+  resume() {
+    if (this.isOpen()) {
+      this._isReady = true;
+      this.doPull();
+    }
+  }
+}
+const defaultInlet = throttle();
+function pipe() {
+  var v = arguments[0];
+  for (var i = 1; i < arguments.length; i++)
+    v = arguments[i](v);
+  return v;
+}
+function compose(...fns) {
+  return (val) => pipe(val, ...fns);
+}
+function into(...args) {
+  return (src) => src(...args);
+}
+
+function must(cleanup) {
+  getJob().must(cleanup);
+}
+function start(init, fn) {
+  return getJob().start(init, fn);
+}
+function isJobActive() {
+  return !!current.job;
+}
+const timers = /* @__PURE__ */ new WeakMap();
+function timeout(ms = 0, job = getJob()) {
+  let timer = timers.get(job);
+  if (timer) {
+    clearTimeout(timer);
+  } else if (timer === void 0 && !job.result()) {
+    job.must(timeout.bind(null, 0, job));
+  }
+  if (job.result()) {
+    timers.delete(job);
+  } else if (ms) {
+    timers.set(job, setTimeout(() => {
+      timers.set(job, null);
+      job.end();
+    }, ms));
+  } else {
+    timers.set(job, null);
+  }
+  return job;
+}
+const abortSignals = /* @__PURE__ */ new WeakMap();
+function abortSignal(job = getJob()) {
+  let signal = abortSignals.get(job);
+  if (!signal) {
+    const ctrl = new AbortController();
+    signal = ctrl.signal;
+    job.must(() => {
+      abortSignals.set(job, null);
+      ctrl.abort();
+    });
+    abortSignals.set(job, signal);
+    if (job.result())
+      ctrl.abort();
+  }
+  return signal;
+}
+function restarting(task2) {
+  const outer = getJob(), inner = makeJob(outer), { end } = inner;
+  task2 ||= (f) => {
+    inner.must(f());
+  };
+  inner.asyncCatch((e) => outer.asyncThrow(e));
+  return function() {
+    inner.restart().must(outer.release(end));
+    const old = swapCtx(makeCtx(inner));
+    try {
+      return apply(task2, this, arguments);
+    } catch (e) {
+      inner.restart();
+      throw e;
+    } finally {
+      freeCtx(swapCtx(old));
+    }
+  };
+}
+function task(fn, _ctx, desc) {
+  if (desc)
+    return { ...desc, value: task(desc.value) };
+  return function(...args) {
+    return start(fn.bind(this, ...args));
+  };
+}
+
+function callOrWait(source, method, handler, noArgs) {
+  if (source && isFunction(source[method]))
+    return source[method]();
+  if (isFunction(source))
+    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));
+      });
+    });
+  mustBeSourceOrSignal();
+}
+function mustBeSourceOrSignal() {
+  throw new TypeError("not a source or signal");
+}
+
+export { CancelError as A, nativePromise as B, CancelResult as C, makeJob as D, ErrorResult as E, pipe as F, compose as G, into as H, IsStream as I, isJobActive as J, timeout as K, abortSignal as L, task as M, swapCtx as N, nullCtx as O, ruleQueue as P, defaultQ as Q, currentRule as R, makeCtx as S, ruleStops as T, freeCtx as U, ValueResult as V, rejecter as a, resolve as b, backpressure as c, defer as d, detached as e, isUnhandled as f, getJob as g, markHandled as h, isCancel as i, isError as j, connect as k, fulfillPromise as l, must as m, noop as n, callOrWait as o, restarting as p, current as q, resolver as r, start as s, throttle as t, mustBeSourceOrSignal as u, isValue as v, reject as w, isHandled as x, getResult as y, propagateResult as z };
+//# sourceMappingURL=call-or-wait-DHkBd_bM.mjs.map