Module uneventful

Get an AbortSignal that aborts when the job ends or is restarted.

Return the currently-active Job, or throw an error if none is active.

Get the return value from a JobResult, throwing an appropriate error if the result isn't a ValueResult.

Is there a currently active job? (i.e., can you safely use must(), or getJob() right now?)

Return a new Job. If either a parent parameter or stop function are given, the new job is linked to the parent.

Add a cleanup function to the active job. Non-function values are ignored. Equivalent to calling .must() on the current job. (See Job.must() for more details.)

Obtain a native promise for a job

Create a new root job (usually for testing purposes). If there is an existing root job, it is ended first. The new root is configured to convert async errors into unhandled promise rejections by default, so if you need to change that you can use its .asyncCatch() method.

Wrap a function in a Job that restarts each time the resulting function is called, thereby canceling any nested jobs and cleaning up any resources used by previous calls. (This can be useful for such things as canceling an in-progress search when the user types more text in a field.)

The "main" job of the program or bundle, which all other jobs should be a child of. This provides a single point of configuration and cleanup, as one can e.g.:

Start a nested job within the currently-active job. (Shorthand for calling .start(...) on the active job.)

Wrap an argument-taking function so it will run in (and returns) a new Job when called.

Invoke a no-argument function as a microtask, using queueMicrotask or Promise.resolve().then()

Wait for and return the next value (or error) from a data source (when processed with yield * within a Job).

Pause the job for the specified time in ms, e.g. yield *sleep(1000) to wait one second.

Set the cancellation timeout for a job.

Convert a (possible) promise to something you can yield *to() in a job

Find out whether the active signal is being observed, or just queried.

Arrange for the current signal or rule to recalculate on demand

Subscribe a sink to a stream, returning a nested job. (Shorthand for .connect(...) on the active job.)

Asynchronously iterate over an event source

Run a restarting() callback for each value produced by a source.

Pass subscriber into a stream (or any arguments into any other function).

Wait for and return the next value (or error) from a data source (when processed with yield * within a Job).

A function that does nothing and returns void.

Create a backpressure controller for a stream. Pass it to one or more sources you're connecting to, and if they support backpressure they'll respond when you call its .pause() and .resume() methods.

Create a backpressure control function for the given connection

Create an event source and a function to emit events on it

A stream that immediately closes

Convert an async iterable to an event source

Create an event source from an element, window, or other event target

Convert an iterable to a synchronous event source

Convert a Promise to an event source

Create an event source from an arbitrary subscribe/unsubscribe function

Create a source that emits a single given value

Create an event source that issues a number every ms milliseconds (starting with 0 after the first interval passes).

Create a dynamic source that is created each time it's subscribed

Like emitter, but with a ready() backpressure method. It also only supports a single active subscriber. (Useful for testing stream operators and sinks.)

A stream that never emits or closes

Compose a series of single-argument functions/operators in application order. (This is basically a deferred version of pipe().) For example:

Output multiple streams' contents in order (from an array/iterable of stream sources)

Flatten a source of sources by emitting their contents in series

Map each value of a stream to a substream, then concatenate the resulting substreams

Create a subset of a stream, based on a filter function (like Array.filter)

Replace each value in a stream using a function (like Array.map)

Create an event source by merging an array or iterable of event sources.

Create an event source by merging sources from a stream of event sources

Create an event source by merging sources created by mapping events to sources

Pipe a stream (or anything else) through a series of single-argument functions/operators

Wrap a source to allow multiple subscribers to the same underlying stream

Skip the first N items from a source

Skip items from a stream until another source produces a value.

Skip items from a stream until a given condition is false, then output all remaining items. The condition function is not called again once it returns false.

Add job control and buffering to a stream

Flatten a source of sources by emitting their contents until a new one arrives.

Map each value of a stream to a substream, then output the resulting substreams until a new value arrives.

Take the first N items from a source

Take items from a source until another source produces a value.

Take items from a stream until a given condition is false, then close the output. The condition function is not called again after it returns false.

The JobResult used to indicate a canceled job.

Create an ErrorResult from an error

Fulfill a Promise from a JobResult

Returns true if the given result is a CancelResult.

Returns true if the given result is a ErrorResult.

Returns true if the given result is a HandledError (an ErrorResult that has been touched by markHandled).

Returns true if the given result is an UnhandledError.

Returns true if the given result is a ValueResult.

Return the error of an ErrorResult and mark it as handled. The ErrorResult is mutated in-place to become a HandledError.

Propagate a JobResult to another job

Reject a Request with a reason.

Create a callback that will reject the given Request with a reason.

Resolve a Request with a value.

Create a callback that will resolve the given Request with a value.

Create a ValueResult from a value

Any function

An asynchronous start function is called immediately in the new job and must return a StartObj, such as a job, generator, or promise. If a job or promise is returned, it will be awaited and its result used to asynchronously set the result of the returned job.

A backpressure controller: returns true if downstream is ready to accept data.

A JobResult that indicates the job was canceled by its creator (via end() or restart()).

A cleanup function is a callback invoked when a job is ended or restarted. It receives a result that indicates whether the job ended itself with a return value or error, or was canceled/restarted by its creator.

A Connection is a job that returns void when the connected stream ends itself. If the stream doesn't end itself (e.g. it's an event listener), the job will never return, and only end with a cancel or throw.

A function that can be called to dispose of something or unsubscribe something. It's called without arguments and returns void.

The iterable returned by yield * each()

The result type returned from calls to Each.next()

A function that emits events, with a .source they're emitted from

A JobResult that indicates the job was ended via a throw() or other error.

An ErrorResult that has been marked "handled" (by being passed to an error-specific handler, converted to a promise, given to markHandled, etc.)

Control backpressure for listening streams. This interface is the API internal to the implementation of backpressure(). Unless you're implementing a backpressurable stream yourself, see the Throttle interface instead.

A specially-typed string used to verify that a function supports uneventful's streaming protocol. Return it from a function to implement the Source type.

A cancellable asynchronous operation with automatic resource cleanup.

An iterator yielding Suspend callbacks. (An implementation detail of the Yielding type.)

A result passed to a job's cleanup callbacks, or supplied by its .result() method.

An Emitter with a ready() method, that only supports a single active subscriber. (Useful for testing stream operators and sinks.)

An object that can be waited on with yield *next(), by calling its "uneventful.next" method. (This mostly exists to allow Signals to optimize their next() implementation, but is also open for extensions.)

An undefined or null value

An optional cleanup parameter or return.

A function without a this

A subscribable function used to trigger signal recalculations

A request for a value (or error) to be returned asynchronously.

The call signatures implemented by signals. (They can be used as sources, or called with no arguments to return a value.)

A Sink is a function that receives data from a Stream.

A Source is a function that can be called to arrange for data to be produced and sent to a Sink function for consumption, until the associated Connection is closed (either by the source or the sink, e.g. if the sink doesn't want more data or the source has no more to send).

A synchronous or asynchronous initializing function for use with the start() function or a job's .start() method.

An object that can be passed as a single argument to start() or a job's .start() method, such as a job, generator, or promise.

An uneventful stream is either a Source or a SignalSource. (Signals actually implement the Source interface as an overload, but TypeScript gets confused about that sometimes, so we generally declare our stream inputs as Stream<T> and our stream outputs as Source, so that TypeScript knows what's what.

An asynchronous operation that can be waited on by a Job.

A synchronous start function returns void or a CleanupFn. It runs immediately and gets passed the newly created job as its first argument.

Control backpressure for listening streams

A Transformer is a function that takes one stream and returns another, possibly one that produces data of a different type. Most operator functions return a transformer, allowing them to be combined via pipe().

An ErrorResult that hasn't yet been "handled" (by being passed to an error-specific handler, converted to a promise, given to markHandled, etc.)

An object that can be waited on with yield *until(), by calling its "uneventful.until" method. (This mostly exists to allow Signals to optimize their until() implementation, but is also open for extensions.)

A JobResult that indicates the job was ended via a return() value.

A pausable computation that ultimately produces a value of type T.

Error thrown when waiting for a result from a job that is canceled.