uneventful 0.0.10 → 0.0.11

package/dist/mod.mjs

@@ -1,8 +1,8 @@
-import { d as defer, i as isFunction } from './utils-DnMz1K-o.mjs';
-import { r as resolver, a as rejecter, b as resolve, m as must, s as start, g as getJob, n as noop, c as root, i as isCancel, d as isUnhandled, e as markHandled, f as isError, h as fulfillPromise, j as restarting, k as current, l as isValue } from './jobutils-CmHay7sf.mjs';
-export { u as CancelError, C as CancelResult, E as ErrorResult, V as ValueResult, B as abortSignal, x as detached, q as getResult, p as isHandled, z as isJobActive, w as makeJob, v as nativePromise, y as newRoot, t as propagateResult, o as reject, D as task, A as timeout } from './jobutils-CmHay7sf.mjs';
-import { I as IsStream, b as backpressure, t as throttle, c as connect, a as callOrWait, m as mustBeSourceOrSignal } from './call-or-wait-DORP7nkp.mjs';
-export { d as compose, i as into, p as pipe } from './call-or-wait-DORP7nkp.mjs';
+import { d as defer, i as isFunction } from './utils-cyEhnyp7.mjs';
+import { r as resolver, a as rejecter, b as resolve, m as must, s as start, g as getJob, n as noop, c as root, i as isCancel, d as isUnhandled, e as markHandled, f as isError, h as fulfillPromise, j as restarting, k as currentCell, l as isValue } from './jobutils-Dvu-e99o.mjs';
+export { u as CancelError, C as CancelResult, E as ErrorResult, V as ValueResult, B as abortSignal, x as detached, q as getResult, p as isHandled, z as isJobActive, w as makeJob, v as nativePromise, y as newRoot, t as propagateResult, o as reject, D as task, A as timeout } from './jobutils-Dvu-e99o.mjs';
+import { I as IsStream, b as backpressure, t as throttle, c as connect, a as callOrWait, m as mustBeSourceOrSignal } from './call-or-wait-EzXJX5Dq.mjs';
+export { d as compose, i as into, p as pipe } from './call-or-wait-EzXJX5Dq.mjs';
 
 function* to(p) {
   return yield (res) => Promise.resolve(p).then(resolver(res), rejecter(res));
@@ -276,10 +276,10 @@ function forEach(src, sink, inlet) {
   return (src2) => forEach(src2, sink, inlet);
 }
 function recalcWhen(fnOrKey, fn) {
-  current.cell?.recalcWhen(fnOrKey, fn);
+  currentCell?.recalcWhen(fnOrKey, fn);
 }
 function isObserved() {
-  return current.cell?.isObserved();
+  return currentCell?.isObserved();
 }
 
 function concat(sources) {
@@ -371,7 +371,7 @@ function slack(size, dropped = noop) {
     conn.connect(src, (v) => {
       buffer.push(v);
       if (!draining && ready())
-        return drain();
+        return void drain();
       while (buffer.length > max) {
         dropped(size < 0 ? buffer.pop() : buffer.shift());
       }
@@ -401,6 +401,7 @@ function slack(size, dropped = noop) {
       } finally {
         draining = false;
       }
+      return false;
     }
     return IsStream;
   };
@@ -441,4 +442,3 @@ function takeWhile(condition) {
 }
 
 export { IsStream, backpressure, concat, concatAll, concatMap, connect, defer, each, emitter, empty, filter, forEach, fromAsyncIterable, fromDomEvent, fromIterable, fromPromise, fromSubscribe, fromValue, fulfillPromise, getJob, interval, isCancel, isError, isObserved, isUnhandled, isValue, lazy, map, markHandled, merge, mergeAll, mergeMap, mockSource, must, never, next, noop, recalcWhen, rejecter, resolve, resolver, restarting, root, share, skip, skipUntil, skipWhile, slack, sleep, start, switchAll, switchMap, take, takeUntil, takeWhile, throttle, to };
-//# sourceMappingURL=mod.mjs.map

package/dist/shared.mjs

@@ -1,5 +1,5 @@
-import { c as root, m as must, s as start, n as noop } from './jobutils-CmHay7sf.mjs';
-import { a as isGeneratorFunction, b as decorateMethod, i as isFunction, c as apply, s as setMap } from './utils-DnMz1K-o.mjs';
+import { c as root, m as must, s as start, n as noop } from './jobutils-Dvu-e99o.mjs';
+import { a as isGeneratorFunction, b as decorateMethod, i as isFunction, c as apply, s as setMap } from './utils-cyEhnyp7.mjs';
 
 function service(factory) {
   let known = false, value = void 0;
@@ -50,4 +50,3 @@ function fork(genOrFunc, ...args) {
 const forks = /* @__PURE__ */ new WeakMap();
 
 export { expiring, fork, service };
-//# sourceMappingURL=shared.mjs.map

package/dist/signals.d.ts

@@ -195,6 +195,7 @@ interface RuleFactory {
  * @returns A function that can be called to terminate the rule.
  *
  * @category Reactive Behaviors
+ * @function
  */
 declare const rule: ((fn: () => OptionalCleanup) => DisposeFn) & RuleFactory;
 /**

package/dist/signals.mjs

@@ -1,6 +1,6 @@
-import { F as swapCtx, G as nullCtx, k as current, H as makeCtx, w as makeJob, c as root, f as isError, e as markHandled, g as getJob, x as detached, o as reject, b as resolve, I as freeCtx } from './jobutils-CmHay7sf.mjs';
-import { b as backpressure, I as IsStream, a as callOrWait } from './call-or-wait-DORP7nkp.mjs';
-import { e as batch, f as arrayEq, d as defer, c as apply, s as setMap, C as CallableObject } from './utils-DnMz1K-o.mjs';
+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) {
@@ -32,6 +32,14 @@ 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();
@@ -129,6 +137,7 @@ function toggleDemand(c) {
     demandChanges.has(c) ? demandChanges.delete(c) : demandChanges.add(c);
   }
 }
+let dummySource;
 class Cell {
   constructor() {
     this.value = void 0;
@@ -140,7 +149,7 @@ class Cell {
     this.latestSource = timestamp;
     // max lastChanged of this cell or any ancestor source
     this.flags = 0;
-    this.ctx = void 0;
+    this.job = void 0;
     /** The subscription being added during the current calculation - used for uniqueness */
     this.adding = void 0;
     /** Linked list of sources */
@@ -159,11 +168,11 @@ class Cell {
     Cell.mkRule(() => {
       const val = this.getValue();
       if (val !== lastValue) {
-        const old = swapCtx(nullCtx);
+        pushCtx();
         try {
           sink(lastValue = val);
         } finally {
-          swapCtx(old);
+          popCtx();
         }
       }
     }, inlet ? ruleQueue(backpressure(inlet)) : defaultQ);
@@ -172,8 +181,8 @@ class Cell {
   getValue() {
     if (arguments.length)
       return apply(this.stream, this, arguments);
-    const dep = current.cell;
-    if (dep && this.flags & 132 /* Variable */) {
+    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;
@@ -204,7 +213,7 @@ class Cell {
     return this.value;
   }
   shouldWrite(changed) {
-    const cell = current.cell || currentRule;
+    const cell = currentCell || currentRule;
     if (cell) {
       if (!cell.queue)
         throw new WriteConflict("Side-effects not allowed outside rules");
@@ -237,7 +246,6 @@ class Cell {
     if (this.shouldWrite(compute !== this.compute)) {
       this.flags |= 4 /* Compute */;
       this.compute = compute;
-      this.ctx ||= makeCtx(null, this);
     }
   }
   hasBeenRead() {
@@ -253,8 +261,13 @@ class Cell {
     if (validThrough === timestamp)
       return;
     this.validThrough = timestamp;
-    if (!(this.flags & 4 /* Compute */))
+    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;
@@ -275,9 +288,9 @@ class Cell {
       return this.doRecalc();
   }
   doRecalc() {
-    const { ctx } = this, oldCtx = swapCtx(ctx);
+    pushCtx(this.job, this);
     if (this.flags & 64 /* Stateful */) {
-      ctx.job?.restart();
+      this.job?.restart();
     }
     for (let sub = this.sources; sub; sub = sub.nS) {
       sub.ts = -1;
@@ -307,12 +320,12 @@ class Cell {
         demandChanges.delete(this);
         if (this.flags & (16 /* Error */ | 2 /* Stopped */)) {
           this.flags &= ~2 /* Stopped */;
-          ctx.job?.restart();
+          this.job?.restart();
         } else if (this.flags & 1 /* Observed */) ; else {
-          ctx.job?.restart();
+          this.job?.restart();
         }
       }
-      swapCtx(oldCtx);
+      popCtx();
       let head;
       for (let sub = this.sources; sub; ) {
         const pS = sub.pS;
@@ -328,8 +341,12 @@ class Cell {
     }
   }
   becomeConstant() {
-    if (this.flags & (32 /* Running */ | 64 /* Stateful */))
+    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;
@@ -396,14 +413,15 @@ class Cell {
     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.ctx.job ||= makeJob(root, () => {
-      this.ctx.job?.end();
-      this.ctx.job = void 0;
-    });
+    return this.job = makeJob();
   }
   updateDemand() {
     demandChanges.delete(this);
@@ -412,13 +430,12 @@ class Cell {
     } else if (this.flags & 1 /* Observed */) {
       this.shouldWrite(true);
     } else {
-      this.ctx.job?.restart();
+      this.job?.restart();
     }
   }
   static mkStream(src, val) {
     const cell = this.mkValue(val);
-    cell.flags |= 64 /* Stateful */;
-    const ctx = makeCtx();
+    cell.flags |= 64 /* Stateful */ | 256 /* Stream */;
     const write = (v) => {
       cell.setValue(v, false);
     };
@@ -431,27 +448,39 @@ class Cell {
       }
       if (job)
         return;
-      job = ctx.job = makeJob(root).do((r) => {
+      job = makeJob(root).do((r) => {
         if (isError(r)) {
           cell.setValue(markHandled(r), true);
         } else {
           cell.setValue(val, false);
         }
-        ctx.job = job = void 0;
+        job = void 0;
       });
-      const old = swapCtx(ctx);
+      pushCtx(job);
       try {
         src(write, job);
       } catch (e) {
         job.end();
         root.asyncThrow(e);
       } finally {
-        swapCtx(old);
+        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) {
@@ -465,30 +494,28 @@ class Cell {
   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 outer = getJob(), cell = Cell.mkCached(() => {
       try {
-        cell.getJob();
         const cleanup = fn();
         if (cleanup)
-          (cell.ctx.job || cell.getJob()).must(cleanup);
-        cell.lastChanged = timestamp;
+          (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 } = current;
+  const cell = currentCell;
   if (cell) {
     return cell.flags & 16 /* Error */ || !equals(cell.value, newVal) ? newVal : cell.value;
   } else {
@@ -649,27 +676,13 @@ function cached(compute, initVal) {
   );
 }
 function peek(fn, ...args) {
-  if (!current.cell)
-    return fn(...args);
-  const old = swapCtx(makeCtx(current.job));
-  try {
-    return fn(...args);
-  } finally {
-    freeCtx(swapCtx(old));
-  }
+  return currentCell ? currentCell.peek(fn, null, args) : fn(...args);
 }
 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));
-    }
+  return function(...args) {
+    return currentCell ? currentCell.peek(fn, this, args) : apply(fn, this, args);
   };
 }
 function until(source) {
@@ -683,4 +696,3 @@ function waitTruthy(job, v) {
 }
 
 export { CircularDependency, ConfigurableImpl, SignalImpl, WritableImpl, WriteConflict, action, cached, peek, rule, runRules, unchangedIf, until, value };
-//# sourceMappingURL=signals.mjs.map

package/dist/{utils-DnMz1K-o.mjs → utils-cyEhnyp7.mjs}

@@ -79,6 +79,9 @@ const CallableObject = /* @__PURE__ */ (() => {
   return CallableObject2;
 })();
 const apply = Reflect.apply;
+function call(fn, thisArg, ...args) {
+  return thisArg ? apply(fn, thisArg, args) : args.length ? fn(...args) : fn();
+}
 const GeneratorBase = /* @__PURE__ */ (() => {
   function G() {
   }
@@ -90,5 +93,4 @@ function isGeneratorFunction(fn) {
   return isFunction(fn) && fn.prototype instanceof GeneratorBase;
 }
 
-export { CallableObject as C, GeneratorBase as G, isGeneratorFunction as a, decorateMethod as b, apply as c, defer as d, batch as e, arrayEq as f, isArray as g, isFunction as i, setMap as s };
-//# sourceMappingURL=utils-DnMz1K-o.mjs.map
+export { CallableObject as C, GeneratorBase as G, isGeneratorFunction as a, decorateMethod as b, apply as c, defer as d, batch as e, arrayEq as f, isArray as g, call as h, isFunction as i, setMap as s };

package/dist/utils.d.ts

@@ -106,6 +106,7 @@ declare function decorateMethod<F extends AnyFunction, D extends {
  * Shorthand for Array.isArray()
  *
  * @category Data Structures
+ * @function
  */
 declare const isArray: (arg: any) => arg is any[];
 /**
@@ -169,13 +170,25 @@ declare const CallableObject: new <T extends AnyFunction>(fn: T) => T;
  * elements of given array as the arguments.  (Shorthand for Reflect.apply)
  *
  * @category Functions and Decorators
+ * @function
  */
 declare const apply: typeof Reflect.apply;
+/**
+ * Like `fn.call(thisArg, ...args)`, but monomorphic, and the `thisArg`
+ * parameter can be omitted or null.
+ *
+ * This is mostly useful as syntax sugar for an immediately-evaluated function
+ * expression, replacing `(() => {...})()` with `call(() => {...})`.
+ *
+ * @category Functions and Decorators
+ */
+declare function call<F extends AnyFunction>(fn: F, thisArg?: ThisParameterType<F>, ...args: Parameters<F>): ReturnType<F>;
 /**
  * A pseudo-constructor for the abstract ancestor type of all generators,
  * useful for testing whether something is `instanceof Generator`.
  *
  * @category Data Structures
+ * @class
  */
 declare const GeneratorBase: abstract new () => Generator;
 /**
@@ -185,4 +198,4 @@ declare const GeneratorBase: abstract new () => Generator;
  */
 declare function isGeneratorFunction<G extends Generator<any, any, any> = Generator>(fn: any): fn is (this: any, ...args: any[]) => G;
 
-export { type Batch, CallableObject, GeneratorBase, apply, arrayEq, batch, decorateMethod, isArray, isFunction, isGeneratorFunction, setMap };
+export { type Batch, CallableObject, GeneratorBase, apply, arrayEq, batch, call, decorateMethod, isArray, isFunction, isGeneratorFunction, setMap };

package/dist/utils.mjs

@@ -1,2 +1 @@
-export { C as CallableObject, G as GeneratorBase, c as apply, f as arrayEq, e as batch, b as decorateMethod, g as isArray, i as isFunction, a as isGeneratorFunction, s as setMap } from './utils-DnMz1K-o.mjs';
-//# sourceMappingURL=utils.mjs.map
+export { C as CallableObject, G as GeneratorBase, c as apply, f as arrayEq, e as batch, h as call, b as decorateMethod, g as isArray, i as isFunction, a as isGeneratorFunction, s as setMap } from './utils-cyEhnyp7.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "uneventful",
-    "version": "0.0.10",
+    "version": "0.0.11",
     "description": "Declarative, event-driven reactivity: signals, streams, structured concurrency, and easy resource cleanup",
     "keywords": [
         "signals",
@@ -26,6 +26,12 @@
                 "default": "./dist/mod.mjs"
             }
         },
+        "./ext": {
+            "import": {
+                "types": "./dist/ext.d.ts",
+                "default": "./dist/ext.mjs"
+            }
+        },
         "./shared": {
             "import": {
                 "types": "./dist/shared.d.ts",
@@ -47,11 +53,12 @@
     },
     "scripts": {
         "coverage": "c8 -r lcov mocha -n loader=ts-node/esm",
-        "docs": "tsx typedoc/run.mts",
+        "docs": "typedoc",
         "watch": "mocha -r tsx --watch",
-        "watch-docs": "onchange -i --kill \"*.md\"  \"guides/**/*.md\" \"typedoc.config.*\" \"typedoc/*\" -- tsx typedoc/run.mts --watch",
+        "watch-docs": "typedoc --watch",
+        "watch-prep": "pkgroll --watch",
         "test": "mocha -r tsx && pkgroll",
-        "prepare": "pkgroll --sourcemap --clean-dist"
+        "prepare": "pkgroll --clean-dist"
     },
     "mocha": {
         "spec": "specs/*.spec.ts",
@@ -62,28 +69,31 @@
             "README.md"
         ]
     },
+    "ts-node": {
+        "esm": true,
+        "transpileOnly": true,
+        "experimentalSpecifierResolution": "node"
+    },
     "packageManager": "pnpm@7.33.6",
     "devDependencies": {
-        "@knodes/typedoc-plugin-pages": "^0.23.4",
-        "@knodes/typedoc-pluginutils": "^0.23.4",
         "@types/chai": "^4.3.10",
         "@types/chai-as-promised": "^7.1.8",
         "@types/mocha": "^10.0.4",
         "@types/node": "^16",
         "@types/sinon": "^17.0.1",
         "@types/sinon-chai": "^3.2.12",
-        "c8": "^8.0.1",
+        "c8": "^10",
         "chai": "^4.3.10",
         "chai-as-promised": "^7.1.1",
         "mocha": "^10.2.0",
         "monkey-around": "^3",
-        "onchange": "^7.1.0",
         "pkgroll": "^2.1.1",
         "sinon": "^17.0.1",
         "sinon-chai": "^3.7.0",
+        "ts-expect": "^1.3.0",
         "ts-node": "^10.9.1",
-        "tsx": "^4.1.3",
-        "typedoc": "^0.25.13",
+        "tsx": "^4.6.1",
+        "typedoc": "0.28.1",
         "typescript": "^5.4.5"
     }
 }

package/dist/call-or-wait-DORP7nkp.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"call-or-wait-DORP7nkp.mjs","sources":["../src/streams.ts","../src/call-or-wait.ts"],"sourcesContent":["import { pulls } from \"./internals.ts\";\nimport { DisposeFn, Job } from \"./types.ts\";\nimport { getJob } from \"./tracking.ts\";\nimport { current } from \"./ambient.ts\";\nimport type { Signal } from \"./signals.ts\";  // needed for documentation links\n\n/**\n * A backpressure controller: returns true if downstream is ready to accept\n * data.\n *\n * @param cb (optional) - a callback to run when the downstream consumer wishes\n * to resume event production (i.e., when a sink calls\n * {@link Throttle.resume}()).  The callback is automatically unregistered when\n * invoked, so the producer must re-register it after each call if it wishes to\n * keep being called.\n *\n * @category Types and Interfaces\n */\nexport type Backpressure = (cb?: () => any) => boolean\n\n\n/**\n * Create a backpressure control function for the given connection\n *\n * @category Stream Producers\n */\nexport function backpressure(inlet: Inlet = defaultInlet): Backpressure {\n    const job = getJob();\n    return (cb?: Flush) => {\n        if (!job.result() && inlet.isOpen()) {\n            if (cb) inlet.onReady(cb, job);\n            return inlet.isReady();\n        }\n        return false;\n    }\n}\n\n/**\n * Control backpressure for listening streams.  This interface is the API\n * internal to the implementation of {@link backpressure}().  Unless you're\n * implementing a backpressurable stream yourself, see the {@link Throttle}\n * interface instead.\n *\n * @category Types and Interfaces\n */\nexport interface Inlet {\n    /** Is the main connection open?  (i.e. is the creating job not closed yet?) */\n    isOpen(): boolean\n\n    /** Is the connection ready to receive data? */\n    isReady(): boolean\n\n    /**\n     * Register a callback to produce more data when the inlet is resumed\n     * (The callback is unregistered if the supplied job ends.)\n     */\n    onReady(cb: () => any, job: Job): this;\n}\n\n/**\n * Control backpressure for listening streams\n *\n * Obtain instances via {@link throttle}(), then pass them into the appropriate\n * stream-consuming API.  (e.g. {@link connect}).\n *\n * @category Types and Interfaces\n */\nexport interface Throttle extends Inlet {\n    /** Set inlet status to \"paused\". */\n    pause(): void;\n\n    /**\n     * Un-pause, and iterate backpressure-able sources' onReady callbacks to\n     * resume sending immediately.  (i.e., synchronously!)\n     */\n    resume(): void;\n}\n\n/**\n * A Connection is a job that returns void when the connected stream ends\n * itself.  If the stream doesn't end itself (e.g. it's an event listener), the\n * job will never return, and only end with a cancel or throw.\n *\n * @category Types and Interfaces\n */\nexport type Connection = Job<void>;\n\n/**\n * A Source is a function that can be called to arrange for data to be\n * produced and sent to a {@link Sink} function for consumption, until the\n * associated {@link Connection} is closed (either by the source or the sink,\n * e.g. if the sink doesn't want more data or the source has no more to send).\n *\n * If the source is a backpressurable stream, it can use the (optional) supplied\n * inlet (usually a {@link throttle}()) to rate-limit its output.\n *\n * A producer function *must* return the special {@link IsStream} value, so\n * TypeScript can tell what functions are usable as sources.  (Otherwise any\n * void function with no arguments would appear to be usable as a source!)\n *\n * @category Types and Interfaces\n */\nexport interface Source<T> {\n    /** Subscribe sink to receive values */\n    (sink: Sink<T>, conn?: Connection, inlet?: Throttle | Inlet): typeof IsStream;\n}\n\n/**\n * An uneventful stream is either a {@link Source} or a {@link SignalSource}.\n * (Signals actually implement the {@link Source} interface as an overload, but\n * TypeScript gets confused about that sometimes, so we generally declare our\n * stream *inputs* as `Stream<T>` and our stream *outputs* as {@link Source}, so\n * that TypeScript knows what's what.\n *\n * @category Types and Interfaces\n */\nexport type Stream<T> = Source<T> | SignalSource<T>;\n\n/**\n * The call signatures implemented by signals.  (They can be used as sources, or\n * called with no arguments to return a value.)\n *\n * This type is needed because TypeScript won't infer the overloads of\n * {@link Signal} correctly otherwise. (Specifically, it won't allow it to be\n * used as a zero-agument function.)\n *\n * @category Types and Interfaces\n*/\nexport type SignalSource<T> = Source<T> & {\n    /** A signal object can be called to get its current value */\n    (): T\n}\n\n/**\n * A specially-typed string used to verify that a function supports uneventful's\n * streaming protocol.  Return it from a function to implement the\n * {@link Source} type.\n *\n * @category Types and Interfaces\n */\nexport const IsStream = \"uneventful/is-stream\" as const;\n\n/**\n * A `Sink` is a function that receives data from a {@link Stream}.\n *\n * @category Types and Interfaces\n */\nexport type Sink<T> = (val: T) => void;\n\n/**\n * A `Transformer` is a function that takes one stream and returns another,\n * possibly one that produces data of a different type.  Most operator functions\n * return a transformer, allowing them to be combined via {@link pipe}().\n *\n * @category Types and Interfaces\n */\nexport type Transformer<T, V=T> = (input: Stream<T>) => Source<V>;\n\ntype Flush = () => any\n\n\n/**\n * Subscribe a sink to a stream, returning a nested job. (Shorthand for\n * .{@link Job.connect connect}(...) on the active job.)\n *\n * @param src An event source or signal\n * @param sink A callback that will receive the events\n * @param inlet Optional - a {@link throttle}() to control backpressure\n *\n * @returns A job that can be aborted to end the subscription, and which will\n * end naturally (with a void return or error) if the stream ends itself.\n *\n * @category Stream Consumers\n */\nexport function connect<T>(src: Stream<T>, sink: Sink<T>, inlet?: Throttle | Inlet): Connection {\n    return getJob().connect(src, sink, inlet);\n}\n\n/**\n * Create a backpressure controller for a stream.  Pass it to one or more\n * sources you're connecting to, and if they support backpressure they'll\n * respond when you call its .pause() and .resume() methods.\n *\n * @param job - Optional: a job that controls readiness.  (The throttle will\n * pause indefinitely when the job ends.)  Defaults to the currently-active job,\n * but unlike most such defaults, it won't throw if no job is active.\n *\n * @category Stream Consumers\n */\nexport function throttle(job: Job = current.job): Throttle {\n    return new _Throttle(job);\n}\n\nclass _Throttle implements Throttle {\n    /** @internal */\n    protected _callbacks: Map<Flush, DisposeFn> = undefined;\n\n    /** @internal */\n    constructor(protected _job?: Job) {}\n\n    isOpen(): boolean { return !this._job?.result(); }\n\n    /** Is the connection ready to receive data? */\n    isReady(): boolean { return this.isOpen() && this._isReady; }\n\n    _isReady = true;\n    _isPulling = false;\n\n    onReady(cb: Flush, job: Job) {\n        if (!this.isOpen()) return this;\n        const _callbacks = (this._callbacks ||= new Map);\n        const unlink = job.release(() => _callbacks.delete(cb));\n        if (this.isReady() && this && !_callbacks.size) {\n            pulls.add(this);\n        }\n        _callbacks.set(cb, unlink);\n        return this;\n    }\n\n    pause() { this._isReady = false; return this; }\n\n    doPull() {\n        if (this._isPulling) return;\n        const {_callbacks} = this;\n        if (!_callbacks?.size) return;\n        this._isPulling = true;\n        try {\n            for(let [cb, unlink] of _callbacks) {\n                if (!this.isReady()) break;  // we're done\n                unlink()\n                _callbacks.delete(cb);\n                cb() // XXX error handling?\n            }\n        } finally {\n            this._isPulling = false;\n        }\n    }\n\n    resume() {\n        if (this.isOpen()) {\n            this._isReady = true;\n            this.doPull();\n        }\n    }\n}\n\nconst defaultInlet: Inlet = throttle();\n\n/**\n * Pipe a stream (or anything else) through a series of single-argument\n * functions/operators\n *\n * e.g. the following creates a stream that outputs 4 and then 6:\n *\n * ```ts\n * pipe(fromIterable([1,2,3,4]), skip(1), take(2), map(x => x*2))\n * ```\n *\n * The first argument to pipe() can be any value, but all other arguments must\n * be functions.  The value is passed to the first function, and then the result\n * is passed to the next function in turn, until all provided functions have\n * been called with the result of the previous function.  The return value is\n * the last result, or the original value if no functions were given.\n *\n * The underlying implementation of pipe() works with any number of arguments,\n * but due to TypeScript limitations we only have typing defined for a max of 9\n * functions (10 arguments total).  If you need more than 9 functions, you can\n * stack some of them with {@link compose}(), e.g.:\n *\n * ```typescript\n * pipe(\n *     aStream,\n *     compose(op1, op2, ...),\n *     compose(op10, op11, ...),\n *     compose(op19, ...),\n *     ...\n * )\n * ```\n *\n * @category Stream Operators\n */\nexport function pipe<A,B,C,D,E,F,G,H,I,J>(input: A, ...fns: Chain9<A,J,B,C,D,E,F,G,H,I>): J\nexport function pipe<A,B,C,D,E,F,G,H,I>  (input: A, ...fns: Chain8<A,I,B,C,D,E,F,G,H>):   I\nexport function pipe<A,B,C,D,E,F,G,H>    (input: A, ...fns: Chain7<A,H,B,C,D,E,F,G>):     H\nexport function pipe<A,B,C,D,E,F,G>      (input: A, ...fns: Chain6<A,G,B,C,D,E,F>):       G\nexport function pipe<A,B,C,D,E,F>        (input: A, ...fns: Chain5<A,F,B,C,D,E>):         F\nexport function pipe<A,B,C,D,E>          (input: A, ...fns: Chain4<A,E,B,C,D>):           E\nexport function pipe<A,B,C,D>            (input: A, ...fns: Chain3<A,D,B,C>):             D\nexport function pipe<A,B,C>              (input: A, ...fns: Chain2<A,C,B>):               C\nexport function pipe<A,B>                (input: A, ...fns: Chain1<A,B>):                 B\nexport function pipe<A>                  (input: A): A\nexport function pipe(input: any, ...fns: Array<(v: any) => any>): any;\nexport function pipe<A,X>(): X {\n    var v = arguments[0];\n    for (var i=1; i<arguments.length; i++) v = arguments[i](v);\n    return v;\n}\n\n/**\n * Compose a series of single-argument functions/operators in application order.\n * (This is basically a deferred version of {@link pipe}().)  For example:\n *\n * ```ts\n * const func = compose(skip(1), take(2), map(x => x*2));\n * const stream_4_6 = func(fromIterable([1,2,3,4])); // stream that outputs 4, 6\n * ```\n *\n * As with `pipe()`, the declared typings only support composing up to 9\n * functions at once; if you need more you'll need to nest calls to `compose()`\n * (i.e. passing the result of a `compose()` as an argument to another\n * `compose()` call.)\n *\n * @returns A function taking the same type as the first input function,\n * returning the same type as the last input function.\n *\n * @category Stream Operators\n */\nexport function compose<A,B,C,D,E,F,G,H,I,J>(...fns: Chain9<A,J,B,C,D,E,F,G,H,I>): (a: A) => J\nexport function compose<A,B,C,D,E,F,G,H,I>  (...fns: Chain8<A,I,B,C,D,E,F,G,H>):   (a: A) => I\nexport function compose<A,B,C,D,E,F,G,H>    (...fns: Chain7<A,H,B,C,D,E,F,G>):     (a: A) => H\nexport function compose<A,B,C,D,E,F,G>      (...fns: Chain6<A,G,B,C,D,E,F>):       (a: A) => G\nexport function compose<A,B,C,D,E,F>        (...fns: Chain5<A,F,B,C,D,E>):         (a: A) => F\nexport function compose<A,B,C,D,E>          (...fns: Chain4<A,E,B,C,D>):           (a: A) => E\nexport function compose<A,B,C,D>            (...fns: Chain3<A,D,B,C>):             (a: A) => D\nexport function compose<A,B,C>              (...fns: Chain2<A,C,B>):               (a: A) => C\nexport function compose<A,B>                (...fns: Chain1<A,B>):                 (a: A) => B\nexport function compose<A>                  (): (a: A) => A\nexport function compose(...fns: ((v:any)=>any)[]) {\n    return (val:any) => (pipe as any)(val, ...fns);\n}\n\ntype Chain1<A,R>                 = [(v: A) => R];\ntype Chain2<A,R,B>               = [...Chain1<A,B>, ...Chain1<B,R>];\ntype Chain3<A,R,B,C>             = [...Chain1<A,B>, ...Chain2<B,R,C>];\ntype Chain4<A,R,B,C,D>           = [...Chain1<A,B>, ...Chain3<B,R,C,D>];\ntype Chain5<A,R,B,C,D,E>         = [...Chain1<A,B>, ...Chain4<B,R,C,D,E>];\ntype Chain6<A,R,B,C,D,E,F>       = [...Chain1<A,B>, ...Chain5<B,R,C,D,E,F>];\ntype Chain7<A,R,B,C,D,E,F,G>     = [...Chain1<A,B>, ...Chain6<B,R,C,D,E,F,G>];\ntype Chain8<A,R,B,C,D,E,F,G,H>   = [...Chain1<A,B>, ...Chain7<B,R,C,D,E,F,G,H>];\ntype Chain9<A,R,B,C,D,E,F,G,H,I> = [...Chain1<A,B>, ...Chain8<B,R,C,D,E,F,G,H,I>];\n\n/**\n * Pass subscriber into a stream (or any arguments into any other function).\n *\n * This utility is mainly here for uses like:\n *\n * - `pipe(src, into(sink))`,\n * - `pipe(src, into(sink, conn))`,\n * - `pipe(src, into(restarting(sink)))`, etc.\n *\n * but can also be used for argument currying generally.\n *\n * @param args The arguments to pass to the stream (or other function)\n *\n * @returns a function that takes another function and calls it with the given args.\n *\n * @category Stream Consumers\n */\nexport function into<In extends any[], Out>(...args: In): (src: (...args: In) => Out) => Out {\n    return src => src(...args);\n}\n","import { Job, Yielding } from \"./types.ts\";\nimport { start } from \"./jobutils.ts\";\nimport { isValue, isError, markHandled } from \"./results.ts\";\nimport { isFunction } from \"./utils.ts\";\nimport { connect, Source } from \"./streams.ts\";\n\nexport function callOrWait<T>(\n    source: any, method: string, handler: (job: Job<T>, val: T) => void, noArgs: (f?: any) => Yielding<T> | void\n) {\n    if (source && isFunction(source[method])) return source[method]() as Yielding<T>;\n    if (isFunction(source)) return (\n        source.length === 0 ? noArgs(source) : false\n    ) || start<T>(job => {\n        connect(source as Source<T>, v => handler(job, v)).do(r => {\n            if (isValue(r)) job.throw(new Error(\"Stream ended\"));\n            else if (isError(r)) job.throw(markHandled(r));\n        });\n    });\n    mustBeSourceOrSignal();\n}\n\nexport function mustBeSourceOrSignal() { throw new TypeError(\"not a source or signal\"); }\n"],"names":[],"mappings":"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"}