uneventful 0.0.12 → 0.0.13

package/dist/{types-N2ua11te.d.ts → types-pElgImr7.d.ts}

@@ -214,6 +214,9 @@ declare function propagateResult<T>(job: Job<T>, res: JobResult<T>): void;
 declare class CancelError extends Error {
 }
 
+/** An optional value @inline */
+type Maybe<T> = T | undefined;
+
 /**
  * A backpressure controller: returns true if downstream is ready to accept
  * data.
@@ -367,40 +370,7 @@ declare function connect<T>(src: Stream<T>, sink: Sink<T>, inlet?: Throttle | In
  *
  * @category Stream Consumers
  */
-declare function throttle(job?: Job): Throttle;
-/**
- * Pipe a stream (or anything else) through a series of single-argument
- * functions/operators
- *
- * e.g. the following creates a stream that outputs 4 and then 6:
- *
- * ```ts
- * pipe(fromIterable([1,2,3,4]), skip(1), take(2), map(x => x*2))
- * ```
- *
- * The first argument to pipe() can be any value, but all other arguments must
- * be functions.  The value is passed to the first function, and then the result
- * is passed to the next function in turn, until all provided functions have
- * been called with the result of the previous function.  The return value is
- * the last result, or the original value if no functions were given.
- *
- * The underlying implementation of pipe() works with any number of arguments,
- * but due to TypeScript limitations we only have typing defined for a max of 9
- * functions (10 arguments total).  If you need more than 9 functions, you can
- * stack some of them with {@link compose}(), e.g.:
- *
- * ```typescript
- * pipe(
- *     aStream,
- *     compose(op1, op2, ...),
- *     compose(op10, op11, ...),
- *     compose(op19, ...),
- *     ...
- * )
- * ```
- *
- * @category Stream Operators
- */
+declare function throttle(job?: Maybe<Job<any>>): Throttle;
 declare 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;
 declare 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;
 declare function pipe<A, B, C, D, E, F, G, H>(input: A, ...fns: Chain7<A, H, B, C, D, E, F, G>): H;
@@ -412,25 +382,6 @@ declare function pipe<A, B, C>(input: A, ...fns: Chain2<A, C, B>): C;
 declare function pipe<A, B>(input: A, ...fns: Chain1<A, B>): B;
 declare function pipe<A>(input: A): A;
 declare function pipe(input: any, ...fns: Array<(v: any) => any>): any;
-/**
- * Compose a series of single-argument functions/operators in application order.
- * (This is basically a deferred version of {@link pipe}().)  For example:
- *
- * ```ts
- * const func = compose(skip(1), take(2), map(x => x*2));
- * const stream_4_6 = func(fromIterable([1,2,3,4])); // stream that outputs 4, 6
- * ```
- *
- * As with `pipe()`, the declared typings only support composing up to 9
- * functions at once; if you need more you'll need to nest calls to `compose()`
- * (i.e. passing the result of a `compose()` as an argument to another
- * `compose()` call.)
- *
- * @returns A function taking the same type as the first input function,
- * returning the same type as the last input function.
- *
- * @category Stream Operators
- */
 declare 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;
 declare 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;
 declare function compose<A, B, C, D, E, F, G, H>(...fns: Chain7<A, H, B, C, D, E, F, G>): (a: A) => H;
@@ -441,6 +392,7 @@ declare function compose<A, B, C, D>(...fns: Chain3<A, D, B, C>): (a: A) => D;
 declare function compose<A, B, C>(...fns: Chain2<A, C, B>): (a: A) => C;
 declare function compose<A, B>(...fns: Chain1<A, B>): (a: A) => B;
 declare function compose<A>(): (a: A) => A;
+/** @inline */
 type Chain1<A, R> = [(v: A) => R];
 type Chain2<A, R, B> = [...Chain1<A, B>, ...Chain1<B, R>];
 type Chain3<A, R, B, C> = [...Chain1<A, B>, ...Chain2<B, R, C>];
@@ -577,8 +529,7 @@ type StartObj<T> = Yielding<T> | Promise<T> | PromiseLike<T>;
  * canceled (using {@link Job.end \.end()} or
  * {@link Job.restart \.restart()}).
  *
- * Jobs can be created using {@link start}(), {@link detached}.start(), and
- * {@link makeJob}().
+ * Jobs can be created using {@link start}() and {@link root}.start().
  *
  * @category Types and Interfaces
  */
@@ -750,7 +701,7 @@ interface Job<T = any> extends Yielding<T>, Promise<T> {
      *
      * @category Obtaining Results
      */
-    do(action: (res?: JobResult<T>) => unknown): this;
+    do(action: (res: JobResult<T>) => unknown): this;
     /**
      * Invoke a callback if the job ends with an error.
      *
@@ -814,7 +765,7 @@ interface Job<T = any> extends Yielding<T>, Promise<T> {
      * will be called with the error, otherwise the job will end with the
      * supplied error.  If the error then isn't handled by a listener on the
      * job, the error will cascade to an asyncThrow on the job's parent, until
-     * the {@link detached} job and its asyncCatch handler is reached. (Which
+     * the {@link root} job and its asyncCatch handler is reached. (Which
      * defaults to creating an unhandled promise rejection.)
      *
      * Note: application code should not normally need to call this method

package/dist/{utils-cyEhnyp7.mjs → utils-BgqyDPjA.mjs}

@@ -71,6 +71,36 @@ function setMap(map, key, val) {
 function isFunction(f) {
   return typeof f === "function";
 }
+function isPlainFunction(f) {
+  const t = functionType(f, 3 /* ES6_CLASS */);
+  return t === 1 /* PLAIN */ || t === 2 /* BOUND */;
+}
+function functionType(fn, checkClass) {
+  var prot;
+  switch (true) {
+    case !isFunction(fn):
+      return 0 /* NON_FUNC */;
+    case Object.getPrototypeOf(fn).constructor?.name !== "Function":
+      return 5 /* EXOTIC */;
+    case !(prot = fn.prototype):
+      return 2 /* BOUND */;
+    case (checkClass && fn.toString().startsWith("class")):
+      return 3 /* ES6_CLASS */;
+    case (checkClass === 4 /* ES5_CLASS */ && (!isPlainObject(prot) || // Does it inherit from something other than Object?
+    Object.getOwnPropertyNames(prot).length > 1)):
+      return 4 /* ES5_CLASS */;
+    default:
+      return 1 /* PLAIN */;
+  }
+}
+function isClass(f) {
+  const t = functionType(f, 4 /* ES5_CLASS */);
+  return t === 3 /* ES6_CLASS */ || t === 4 /* ES5_CLASS */;
+}
+function isPlainObject(ob) {
+  var proto;
+  return typeof ob === "object" && ob !== null && (!(proto = Object.getPrototypeOf(ob)) || proto.constructor?.name === "Object");
+}
 const CallableObject = /* @__PURE__ */ (() => {
   function CallableObject2(fn) {
     return Object.setPrototypeOf(fn, new.target.prototype);
@@ -79,8 +109,8 @@ 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();
+function call(fn, thisArg) {
+  return thisArg ? apply(fn, thisArg, [...arguments].slice(2)) : arguments.length < 3 ? fn() : fn(...[...arguments].slice(2));
 }
 const GeneratorBase = /* @__PURE__ */ (() => {
   function G() {
@@ -93,4 +123,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, call as h, isFunction as i, setMap as s };
+export { CallableObject as C, GeneratorBase as G, isGeneratorFunction as a, decorateMethod as b, apply as c, defer as d, isClass as e, isPlainFunction as f, arrayEq as g, batch as h, isFunction as i, isArray as j, isPlainObject as k, call as l, setMap as s };

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { A as AnyFunction } from './types-N2ua11te.js';
+import { A as AnyFunction } from './types-pElgImr7.js';
 
 /**
  * A generic batch processing queue, implemented as a set.  (So items are
@@ -80,9 +80,9 @@ declare function batch<T>(process: (items: Set<T>) => void, sched?: (cb: () => u
  * export function myDecorator<T,D extends {value?: SomeFnType<T>}>(clsOrProto:any, name: string|symbol, desc: D): D
  *
  * // Implementation
- * export function myDecorator<T>(factory: SomeFnType<T>, ...args: any[]): SomeFnType<T> {
+ * export function myDecorator<T>(fn: SomeFnType<T>, ...args: any[]): SomeFnType<T> {
  *     // extra args means we're being used as a decorator, so run as decorator:
- *     if (args.length) return decorateMethod(myDecorator, factory, ...args as [any, any]);
+ *     if (args.length) return decorateMethod(myDecorator, fn, ...args as [any, any]);
  *     // No extra args, we're b
  *     return () => {
  *     }
@@ -137,6 +137,48 @@ declare function setMap<K, V>(map: {
  * @category Functions and Decorators
  */
 declare function isFunction(f: any): f is Function;
+/**
+ * Is the given value a plain synchronous function?
+ *
+ * Returns false if the function is an ES6 class (non-emulated!), async,
+ * generator, or async generator function.  Returns true for regular, arrow, and
+ * bound regular functions.
+ *
+ * Note: a function can return a promise or generator or implement a class, and
+ * yet still not *be* an async function, generator function, or native class.
+ * This function doesn't detect/reject any *emulated* versions of those things,
+ * only native-to-the-engine async/generator functions and classes.  (It also
+ * returns false for {@link CallableObject} instances, or similarly-created
+ * function subclasses.)
+ *
+ * @category Functions and Decorators
+ */
+declare function isPlainFunction(f: any): f is Function;
+/**
+ * Is the given value a class?
+ *
+ * This function detects ES6 native classes, but also ES5-style emmulated
+ * classes, if they're either a subclass (i.e. inherit from something other than
+ * Object), or a base class with public instance methods or other property
+ * descriptors on its prototype.
+ *
+ * It has NO false positives: if it returns true, the thing is definitely a
+ * class by the above rules. But it *can* return a false negative for a plain
+ * constructor function with no base class and no prototype methods.
+ *
+ * @category Functions and Decorators
+ */
+declare function isClass<T>(f: any): f is new () => T;
+/**
+ * Is `ob` a non-null plain object?  (i.e. object literal or created via
+ * `Object.create(null, ...)`)
+ *
+ * @returns true if ob's a non-null of type `object` with a null prototype
+ * or a constructor named `Object`.
+ *
+ * @category Data Structures
+ */
+declare function isPlainObject(ob: any): boolean;
 /**
  * A base class for creating callable objects.
  *
@@ -173,13 +215,16 @@ declare const CallableObject: new <T extends AnyFunction>(fn: T) => T;
  * @function
  */
 declare const apply: typeof Reflect.apply;
+/**
+ * Syntax sugar for an IIFE (i.e. to use `call(() => ...)` instead of `(()=> ...)()` )
+ *
+ * @category Functions and Decorators
+ */
+declare function call<F extends () => any>(fn: F): ReturnType<F>;
 /**
  * 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>;
@@ -198,4 +243,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, call, decorateMethod, isArray, isFunction, isGeneratorFunction, setMap };
+export { type Batch, CallableObject, GeneratorBase, apply, arrayEq, batch, call, decorateMethod, isArray, isClass, isFunction, isGeneratorFunction, isPlainFunction, isPlainObject, setMap };

package/dist/utils.mjs

@@ -1 +1 @@
-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';
+export { C as CallableObject, G as GeneratorBase, c as apply, g as arrayEq, h as batch, l as call, b as decorateMethod, j as isArray, e as isClass, i as isFunction, a as isGeneratorFunction, f as isPlainFunction, k as isPlainObject, s as setMap } from './utils-BgqyDPjA.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "uneventful",
-    "version": "0.0.12",
+    "version": "0.0.13",
     "description": "Declarative, event-driven reactivity: signals, streams, structured concurrency, and easy resource cleanup",
     "keywords": [
         "signals",
@@ -52,12 +52,12 @@
         }
     },
     "scripts": {
-        "coverage": "c8 -r lcov mocha -n loader=ts-node/esm",
+        "coverage": "cross-env TS_NODE_PROJECT=specs/tsconfig.json c8 -r lcov mocha -n loader=ts-node/esm",
         "docs": "typedoc",
-        "watch": "mocha -r tsx --watch",
+        "watch": "pnpm run test --watch",
         "watch-docs": "typedoc --watch",
         "watch-prep": "pkgroll --watch",
-        "test": "mocha -r tsx && pkgroll",
+        "test": "tsx --tsconfig specs/tsconfig.json node_modules/mocha/bin/mocha.js",
         "prepare": "pkgroll --clean-dist"
     },
     "mocha": {
@@ -69,22 +69,21 @@
             "README.md"
         ]
     },
-    "ts-node": {
-        "esm": true,
-        "transpileOnly": true,
-        "experimentalSpecifierResolution": "node"
-    },
     "packageManager": "pnpm@7.33.6",
     "devDependencies": {
         "@types/chai": "^4.3.10",
         "@types/chai-as-promised": "^7.1.8",
+        "@types/markdown-it": "^14.1.2",
+        "@types/markdown-it-footnote": "^3.0.4",
         "@types/mocha": "^10.0.4",
-        "@types/node": "^16",
+        "@types/node": "^18",
         "@types/sinon": "^17.0.1",
         "@types/sinon-chai": "^3.2.12",
         "c8": "^10",
         "chai": "^4.3.10",
         "chai-as-promised": "^7.1.1",
+        "cross-env": "^7.0.3",
+        "markdown-it-footnote": "^4.0.0",
         "mocha": "^10.2.0",
         "monkey-around": "^3",
         "pkgroll": "^2.1.1",
@@ -93,7 +92,7 @@
         "ts-expect": "^1.3.0",
         "ts-node": "^10.9.1",
         "tsx": "^4.6.1",
-        "typedoc": "0.28.2",
-        "typescript": "^5.4.5"
+        "typedoc": "pjeby/typedoc#no-merged-comments",
+        "typescript": "^5.9.3"
     }
 }

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

@@ -1,111 +0,0 @@
-import { g as getJob, H as currentJob, I as pulls, s as start, l as isValue, f as isError, e as markHandled } from './jobutils-Dvu-e99o.mjs';
-import { i as isFunction } from './utils-cyEhnyp7.mjs';
-
-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 = currentJob) {
-  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 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 { IsStream as I, callOrWait as a, backpressure as b, connect as c, compose as d, into as i, mustBeSourceOrSignal as m, pipe as p, throttle as t };