Class Stream<T, E>

Type Parameters

T
Type of the 'values' on the stream.
E
Type of the 'errors' on the stream.

Hierarchy

HigherOrderStream<T, E>
- Stream

Index

Constructors

constructor

new Stream<T, E>(stream): Stream<T, E>
Type Parameters
- T
- E
Parameters
- stream: Readable
Returns Stream<T, E>
Inherited from HigherOrderStream<T, E>.constructor
- Defined in stream/base.ts:23

Properties

`Protected` stackTrace

stackTrace: string[] = []

`Protected` stream

stream: Readable

`Protected` traceComplete

traceComplete: boolean = false

`Static` StreamEnd

StreamEnd: symbol = ...

Marker for the end of a stream.

`Static` WindpipeConsumptionError

WindpipeConsumptionError: typeof WindpipeConsumptionError = WindpipeConsumptionError

Methods

batch

batch(options): Stream<T[], E>
Batch items together on the stream and emit them as an array. The batch can be over some size, or can be over a period of time.
Parameters
- options: {
 byBucket?: ((value) => string | number);
 n?: number;
 timeout?: number;
 yieldEmpty?: boolean;
 yieldRemaining?: boolean;
 }
 - Optional byBucket?: ((value) => string | number)
 - (value): string | number
 Parameters
 value: T
 Returns string | number
 - Optional n?: number
 Batch up to n items (activates batching by count)
 - Optional timeout?: number
 Batch for timeout milliseconds (activates batching by timeout)
 - Optional yieldEmpty?: boolean
 If timeout is reached and no items have been emitted on the stream, still emit an empty array.
 - Optional yieldRemaining?: boolean
Returns Stream<T[], E>
Inherited from HigherOrderStream.batch
- Defined in stream/transforms.ts:427

exhaust

exhaust(): Promise<void>
Completely exhaust the stream, driving it to completion. This is particularly useful when side effects of the stream are desired, but the actual values of the stream are not needed.

Returns Promise<void>
Inherited from HigherOrderStream.exhaust
- Defined in stream/consumption.ts:26

`Protected` getTrace

getTrace(): string[]
Capture the current trace. Creates a clone of the trace to prevent it being modified.

Returns string[]
Inherited from HigherOrderStream.getTrace
- Defined in stream/base.ts:42

onFirst

onFirst(callback, options?): Stream<T, E>
Run the provided callback after the first atom passes through the stream.
Parameters
- callback: (() => void)
 Callback to run.
 - - (): void
 - Returns void
- Optional options: {
 atom?: boolean;
 } = {}
 - Optional atom?: boolean
 Run on any atom (true by default). Will only run after first ok atom if false.
Returns Stream<T, E>
Inherited from HigherOrderStream.onFirst
- Defined in stream/transforms.ts:579

onLast

onLast(callback, options?): Stream<T, E>
Run the provided callback after the last atom passes through the stream.
Parameters
- callback: (() => void)
 Callback to run.
 - - (): void
 - Returns void
- Optional options: {
 atom?: boolean;
 } = {}
 - Optional atom?: boolean
 Run on any atom (true by default). Will only run after last ok atom if false.
Returns Stream<T, E>
Inherited from HigherOrderStream.onLast
- Defined in stream/transforms.ts:604

single

single(options): Promise<undefined | Atom<T, E>>
Pull the stream once and remove the first item. This will not consume the rest of the stream.
Parameters
- options: {
 atom: true;
 optional: true;
 }
 - atom: true
 - optional: true
Returns Promise<undefined | Atom<T, E>>
Note
This method can only be called once on a given stream.
Inherited from HigherOrderStream.single
- Defined in stream/consumption.ts:68
single(options): Promise<Atom<T, E>>
Parameters
- options: {
 atom: true;
 optional?: false;
 }
 - atom: true
 - Optional optional?: false
Returns Promise<Atom<T, E>>
Inherited from HigherOrderStream.single
- Defined in stream/consumption.ts:69
single(options): Promise<undefined | T>
Parameters
- options: {
 atom?: false;
 optional: true;
 }
 - Optional atom?: false
 - optional: true
Returns Promise<undefined | T>
Inherited from HigherOrderStream.single
- Defined in stream/consumption.ts:70
single(options?): Promise<T>
Parameters
- Optional options: {
 atom?: false;
 optional?: false;
 }
 - Optional atom?: false
 - Optional optional?: false
Returns Promise<T>
Inherited from HigherOrderStream.single
- Defined in stream/consumption.ts:71

`Protected` trace

trace(trace): string[]
Add a layer to the trace object. Returns a copy of the current trace.
Parameters
- trace: string
Returns string[]
Inherited from HigherOrderStream.trace
- Defined in stream/base.ts:30

`Static` writable

writable<T, E>(): {
stream: Stream<T, E>;
writable: Writable;
}
Create a stream and corresponding writable Node stream, where any writes to the writable Node stream will be emitted on the returned stream.
Type Parameters
- T
- E = never
Returns {
stream: Stream<T, E>;
writable: Writable;
}
- stream: Stream<T, E>
- writable: Writable
Inherited from HigherOrderStream.writable
- Defined in stream/base.ts:344

Atom

`Static` error

error<T, E>(value): Atom<T, E>
Create an error atom with the provided value.
Type Parameters
- T
- E
Parameters
- value: E
Returns Atom<T, E>
- Defined in stream/index.ts:38

`Static` exception

exception<T, E>(value, trace): Atom<T, E>
Create an exception atom with the provided value.
Type Parameters
- T
- E
Parameters
- value: unknown
- trace: string[]
Returns Atom<T, E>
- Defined in stream/index.ts:47

`Static` isError

isError<T, E>(atom): atom is AtomError<E>
Verify if the provided atom is of the error variant.
Type Parameters
- T
- E
Parameters
- atom: Atom<T, E>
Returns atom is AtomError<E>
- Defined in stream/index.ts:73

`Static` isException

isException<T, E>(atom): atom is AtomException
Verify if the provided atom is of the exception variant.
Type Parameters
- T
- E
Parameters
- atom: Atom<T, E>
Returns atom is AtomException
- Defined in stream/index.ts:82

`Static` isOk

isOk<T, E>(atom): atom is AtomOk<T>
Verify if the provided atom is of the ok variant.
Type Parameters
- T
- E
Parameters
- atom: Atom<T, E>
Returns atom is AtomOk<T>
- Defined in stream/index.ts:64

`Static` isUnknown

isUnknown<T, E>(atom): atom is AtomException
Type Parameters
- T
- E
Parameters
- atom: Atom<T, E>
Returns atom is AtomException
Deprecated
use isException instead
- Defined in stream/index.ts:90

`Static` ok

ok<T, E>(value): Atom<T, E>
Create an ok atom with the provided value.
Type Parameters
- T
- E
Parameters
- value: T
Returns Atom<T, E>
- Defined in stream/index.ts:29

`Static` unknown

unknown<T, E>(value, trace): Atom<T, E>
Type Parameters
- T
- E
Parameters
- value: unknown
- trace: string[]
Returns Atom<T, E>
Deprecated
use exception instead
- Defined in stream/index.ts:55

Consumption

[asyncIterator]

[asyncIterator](): AsyncIterator<Atom<T, E>, any, undefined>
Create an iterator that will emit each atom in the stream.

Returns AsyncIterator<Atom<T, E>, any, undefined>
Inherited from HigherOrderStream.[asyncIterator]
- Defined in stream/consumption.ts:18

serialise

serialise(options?): Readable
Serialise the stream, and produce a Node stream with the serialised result.
Parameters
- Optional options: {
  atoms?: boolean;
  single?: boolean;
  }
  - Optional atoms?: boolean
    By default, only ok values are serialised, however enabling this will serialise all values.
  - Optional single?: boolean
    Whether to emit an array for multiple items, or only a single item.
Returns Readable
Note
this will skip undefined values as they cannot be serialised.

See
Stream#toReadable if serialisation is not required
Inherited from HigherOrderStream.serialise
- Defined in stream/consumption.ts:141

toArray

toArray(options?): Promise<T[]>
Iterate through each atom in the stream, and return them as a single array.
Parameters
- Optional options: {
 atoms?: false;
 reject?: boolean;
 }
 - Optional atoms?: false
 Return every atom on the stream.
 - Optional reject?: boolean
 If an error or exception is encountered, reject the promise with it.
Returns Promise<T[]>
Inherited from HigherOrderStream.toArray
- Defined in stream/consumption.ts:111
toArray(options?): Promise<Atom<T, E>[]>
Parameters
- Optional options: {
 atoms: true;
 }
 - atoms: true
Returns Promise<Atom<T, E>[]>
Inherited from HigherOrderStream.toArray
- Defined in stream/consumption.ts:112

toReadable

toReadable(kind, options?): Readable
Produce a readable node stream with the values from the stream.
Parameters
- kind: "object" | "raw"
  What kind of readable stream to produce. When "raw" only strings and buffers can be emitted on the stream. Use "object" to preserve objects in the readable stream. Note that object values are not serialised, they are emitted as objects.
- Optional options: {
  atoms?: boolean;
  }
  Options for configuring how atoms are output on the stream
  - Optional atoms?: boolean
Returns Readable
See
Stream#serialize if the stream values should be serialized to json
Inherited from HigherOrderStream.toReadable
- Defined in stream/consumption.ts:205
toReadable(kind): Readable
Produce a readable node stream with the raw values from the stream
Parameters
- kind: "raw"
Returns Readable
Note
the stream must only contain atoms of type string or Buffer. If not, a stream error will be emitted.

See
Stream#serialize if the stream values should be serialized to json
Inherited from HigherOrderStream.toReadable
- Defined in stream/consumption.ts:217
toReadable(kind, options?): Readable
Produce a readable node stream in object mode with the values from the stream
Parameters
- kind: "object"
- Optional options: {
  atoms?: boolean;
  }
  - Optional atoms?: boolean
    By default, only ok values are emitted, however enabling this will emit all values.
Returns Readable
Note
When not using options.atoms, any null atom values will be skipped when piping to the readable stream

See
Stream#serialize if the stream values should be serialized to json
Inherited from HigherOrderStream.toReadable
- Defined in stream/consumption.ts:229

values

values(): AsyncIterableIterator<T>
Create an async iterator that will emit each value in the stream.

Returns AsyncIterableIterator<T>
Inherited from HigherOrderStream.values
- Defined in stream/consumption.ts:35

Creation

`Static` from

from<T, E>(value): Stream<T, E>
Create a stream from some kind of stream-like value. This can be an iterable, a promise that resolves to some value, or even another readable stream.
Type Parameters
- T
- E = never
Parameters
- value: Promise<MaybeAtom<T, E>> | Iterator<MaybeAtom<T, E>, any, undefined> | AsyncIterator<MaybeAtom<T, E>, any, undefined> | Iterable<MaybeAtom<T, E>> | AsyncIterable<MaybeAtom<T, E>> | MaybeAtom<T, E>[] | (() => Promise<MaybeAtom<T, E>>)
Returns Stream<T, E>
Inherited from HigherOrderStream.from
- Defined in stream/base.ts:52

`Static` fromArray

fromArray<T, E>(array): Stream<T, E>
Create a stream from an array.
Type Parameters
- T
- E = never
Parameters
- array: MaybeAtom<T, E>[]
 The array that values will be emitted from.
Returns Stream<T, E>
Note
The array will be shallow cloned internally, so that the original array won't be impacted.
Inherited from HigherOrderStream.fromArray
- Defined in stream/base.ts:184

`Static` fromCallback

fromCallback<T, E>(cb): Stream<T, E>
Create a stream from a node-style callback. A node-compatible callback function will be passed as the first parameter to the callback of this function.

The first parameter provided to the callback (the error) will be emitted as an Error atom, whilst the second parameter (the value) will be emitted as an Ok atom.
Type Parameters
- T
- E = never
Parameters
- cb: ((next) => void)
 - - (next): void
 - Parameters
 next: NodeCallback<T, E>
 Returns void
Returns Stream<T, E>
Example
```
$.fromCallback((next) => someAsyncMethod(paramA, paramB, next));
```
Inherited from HigherOrderStream.fromCallback
- Defined in stream/base.ts:102

`Static` fromIterable

fromIterable<T, E>(iterable): Stream<T, E>
Create a stream from an iterable.
Type Parameters
- T
- E = never
Parameters
- iterable: Iterable<MaybeAtom<T, E>> | AsyncIterable<MaybeAtom<T, E>>
 The iterable that will produce an iterator, which may be an async iterator.
Returns Stream<T, E>
Inherited from HigherOrderStream.fromIterable
- Defined in stream/base.ts:164

`Static` fromIterator

fromIterator<T, E>(iterator): Stream<T, E>
Create a stream from an iterator.
Type Parameters
- T
- E = never
Parameters
- iterator: Iterator<MaybeAtom<T, E>, any, undefined> | AsyncIterator<MaybeAtom<T, E>, any, undefined>
 The iterator that will produce values, which may be an async iterator.
Returns Stream<T, E>
Inherited from HigherOrderStream.fromIterator
- Defined in stream/base.ts:141

`Static` fromNext

fromNext<T, E>(next): Stream<T, E>
Create a new stream with the provided atom producer.
Type Parameters
- T
- E = never
Parameters
- next: (() => Promise<symbol | MaybeAtom<T, E>>)
 A callback method to produce the next atom. If no atom is available, then StreamEnd must be returned.
 - - (): Promise<symbol | MaybeAtom<T, E>>
 - Returns Promise<symbol | MaybeAtom<T, E>>
Returns Stream<T, E>
Inherited from HigherOrderStream.fromNext
- Defined in stream/base.ts:202

`Static` fromPromise

fromPromise<T, E>(promise): Stream<T, E>
Create a stream from a promise. The promise will be awaited, and the resulting value only ever emitted once.
Type Parameters
- T
- E = never
Parameters
- promise: Promise<MaybeAtom<T, E>>
 The promise to create the stream from.
Returns Stream<T, E>
Inherited from HigherOrderStream.fromPromise
- Defined in stream/base.ts:120

`Static` fromPusher

fromPusher<T, E>(): {
 done: (() => void);
 push: ((value) => void);
 stream: Stream<T, E>;
}
Create a new stream, and use the provided push and done methods to add values to it, and complete the stream.
- push: Adds the provided value to the stream.
- done: Indicatest that the stream is done, meaning that any future calls to push or done will be ignored.
Type Parameters
- T
- E = never
Returns {
 done: (() => void);
 push: ((value) => void);
 stream: Stream<T, E>;
}
- done: (() => void)
 - - (): void
 - Returns void
- push: ((value) => void)
 - - (value): void
 - Parameters
 value: MaybeAtom<T, E>
 Returns void
- stream: Stream<T, E>
Inherited from HigherOrderStream.fromPusher
- Defined in stream/base.ts:237

`Static` of

of<T, E>(value): Stream<T, E>
Create a new stream containing a single value. Unless an atom is provided, it will be converted to an ok atom.
Type Parameters
- T
- E = never
Parameters
- value: MaybeAtom<T, E>
Returns Stream<T, E>
Inherited from HigherOrderStream.of
- Defined in stream/base.ts:302

`Static` ofError

ofError<T, E>(value): Stream<T, E>
Create a new stream containing a single error atom.
Type Parameters
- T
- E
Parameters
- value: E
Returns Stream<T, E>
Inherited from HigherOrderStream.ofError
- Defined in stream/base.ts:319

`Static` ofException

ofException<T, E>(value): Stream<T, E>
Create a new stream containing a single exception atom.
Type Parameters
- T
- E
Parameters
- value: unknown
Returns Stream<T, E>
Inherited from HigherOrderStream.ofException
- Defined in stream/base.ts:328

`Static` ofUnknown

ofUnknown<T, E>(value): Stream<T, E>
Type Parameters
- T
- E
Parameters
- value: unknown
Returns Stream<T, E>
Deprecated
use ofException instead
Inherited from HigherOrderStream.ofUnknown
- Defined in stream/base.ts:336

Higher Order

cachedFlatMap

cachedFlatMap(cb, keyFn): Stream<U, E>
Map over each value in the stream, produce a stream from it, cache the resultant stream and flatten all the value streams together
Type Parameters
- U
Parameters
- cb: ((value) => MaybePromise<Stream<U, E>>)
 - - (value): MaybePromise<Stream<U, E>>
 - Parameters
 value: T
 Returns MaybePromise<Stream<U, E>>
- keyFn: ((value) => string | number | symbol)
 - - (value): string | number | symbol
 - Parameters
 value: T
 Returns string | number | symbol
Returns Stream<U, E>
Inherited from HigherOrderStream.cachedFlatMap
- Defined in stream/higher-order.ts:146

flatMap

flatMap(cb): Stream<U, E>
Map over each value in the stream, produce a stream from it, and flatten all the value streams together
Type Parameters
- U
Parameters
- cb: ((value) => MaybePromise<Stream<U, E>>)
 - - (value): MaybePromise<Stream<U, E>>
 - Parameters
 value: T
 Returns MaybePromise<Stream<U, E>>
Returns Stream<U, E>
Inherited from HigherOrderStream.flatMap
- Defined in stream/higher-order.ts:83

flatMapError

flatMapError<F>(cb): Stream<T, F>
Map over each error in the stream, produce a stream from it, and flatten all the value streams together.
Type Parameters
- F
Parameters
- cb: ((value) => MaybePromise<Stream<T, F>>)
 - - (value): MaybePromise<Stream<T, F>>
 - Parameters
 value: E
 Returns MaybePromise<Stream<T, F>>
Returns Stream<T, F>
Inherited from HigherOrderStream.flatMapError
- Defined in stream/higher-order.ts:100

flatMapException

flatMapException(cb): Stream<T, E>
Maps over each exception in the stream, producing a new stream from it, and flatten all the value streams together.
Parameters
- cb: ((value, trace) => MaybePromise<Stream<T, E>>)
 - - (value, trace): MaybePromise<Stream<T, E>>
 - Parameters
 value: unknown
 trace: string[]
 Returns MaybePromise<Stream<T, E>>
Returns Stream<T, E>
Inherited from HigherOrderStream.flatMapException
- Defined in stream/higher-order.ts:117

flatMapUnknown

flatMapUnknown(cb): Stream<T, E>
Parameters
- cb: ((value, trace) => MaybePromise<Stream<T, E>>)
 - - (value, trace): MaybePromise<Stream<T, E>>
 - Parameters
 value: unknown
 trace: string[]
 Returns MaybePromise<Stream<T, E>>
Returns Stream<T, E>
Deprecated
use flatMapException instead
Inherited from HigherOrderStream.flatMapUnknown
- Defined in stream/higher-order.ts:134

flatTap

flatTap(cb): Stream<T, E>
Produce a stream for each value in the stream. The resulting stream will be emptied, however the resulting values will just be dropped. This is analogous to an asynchronous side effect.
Parameters
- cb: ((value) => MaybePromise<Stream<unknown, unknown>>)
 - - (value): MaybePromise<Stream<unknown, unknown>>
 - Parameters
 value: T
 Returns MaybePromise<Stream<unknown, unknown>>
Returns Stream<T, E>
Inherited from HigherOrderStream.flatTap
- Defined in stream/higher-order.ts:346

flatten

flatten(): T extends Stream<U, E>
? Stream<U, E>
: Stream<T, E>
Produce a new stream from the stream that has any nested streams flattened

Returns T extends Stream<U, E>
? Stream<U, E>
: Stream<T, E>
Note
Any atoms that are not nested streams are emitted as-is
Inherited from HigherOrderStream.flatten
- Defined in stream/higher-order.ts:194

merge

merge(): T extends Stream<U, E>
? Stream<U, E>
: Stream<T, E>
Produce a new stream from the stream that has any nested streams merged together, emitting their atoms as they are emitted.

Returns T extends Stream<U, E>
? Stream<U, E>
: Stream<T, E>
Note
Any atoms that are not nested streams are emitted as-is
Inherited from HigherOrderStream.merge
- Defined in stream/higher-order.ts:222

otherwise

otherwise<F>(cbOrStream): Stream<T, F>
Emit items from provided stream if this stream is completely empty.
Type Parameters
- F extends unknown
Parameters
- cbOrStream: CallbackOrStream<T, F>
Returns Stream<T, F>
Note
If there are any errors or exceptions on the stream, then the new stream won't be consumed.
Inherited from HigherOrderStream.otherwise
- Defined in stream/higher-order.ts:363

replaceWith

replaceWith<U, F>(cbOrStream): Stream<U, F>
Consume the entire stream, and completely replace it with a new stream. This will remove any errors and exceptions currently on the stream.

Equivalent to:
```
stream
 .filter(() => false)
 .otherwise(newStream);
```
`
Type Parameters
- U
- F
Parameters
- cbOrStream: CallbackOrStream<U, F>
Returns Stream<U, F>
Inherited from HigherOrderStream.replaceWith
- Defined in stream/higher-order.ts:398

Transform

bufferedMap

bufferedMap(cb, options?): Stream<U, E>
Map over each value in the stream, and apply some callback to it. This differs from map as the upstream is continually pulled, regardless if the downstream is ready for it and whether the current iteration has complete.

Example
Approximate timelines are shown below. It isn't 100% correct for what's actually happening, but gives the right idea.
- p: producer (upstream)
- m: map operation (asynchronous)
Map
```
 0ms 10ms 20ms 30ms
 |---------|---------|---------|---------|
 |<-- p -->|<-- m -->| | |
 | | |<-- p -->|<-- m -->|
```
Buffered Map
```
 0ms 10ms 20ms 30ms
 |---------|---------|---------|---------|
 |<-- p -->|<-- m -->| | |
 | |<-- p -->|<-- m -->| |
 | | |<-- p -->|<-- m -->|
```
Type Parameters
- U
Parameters
- cb: ((value) => MaybePromise<MaybeAtom<U, E>>)
 - - (value): MaybePromise<MaybeAtom<U, E>>
 - Parameters
 value: T
 Returns MaybePromise<MaybeAtom<U, E>>
- Optional options: {
 delay?: number;
 maxBufferPeriod?: number;
 maxBufferSize?: number;
 }
 - Optional delay?: number
 - Optional maxBufferPeriod?: number
 - Optional maxBufferSize?: number
Returns Stream<U, E>
Inherited from HigherOrderStream.bufferedMap
- Defined in stream/transforms.ts:341

collect

collect(): Stream<T[], E>
Collect the values of the stream atoms into an array then return a stream which emits that array

Returns Stream<T[], E>
Note
non-ok atoms are emitted as-is, the collected array is always emitted last

Note
empty streams will emit an empty array
Inherited from HigherOrderStream.collect
- Defined in stream/transforms.ts:33

compact

compact(): Stream<Truthy<T>, E>
Remove falsey values from the stream.

This is equivalent to doing .filter((value) => value).

Returns Stream<Truthy<T>, E>
Inherited from HigherOrderStream.compact
- Defined in stream/transforms.ts:189

consume

consume<U, F>(generator): Stream<U, F>
Consume the stream atoms, emitting new atoms from the generator.
Type Parameters
- U
- F
Parameters
- generator: ((it) => AsyncGenerator<Atom<U, F>, any, unknown>)
 - - (it): AsyncGenerator<Atom<U, F>, any, unknown>
 - Parameters
 it: AsyncIterable<Atom<T, E>>
 Returns AsyncGenerator<Atom<U, F>, any, unknown>
Returns Stream<U, F>
Inherited from HigherOrderStream.consume
- Defined in stream/transforms.ts:15

delay

delay(ms): Stream<T, E>
Delay emitting each value on the stream by ms.
Parameters
- ms: number
Returns Stream<T, E>
Inherited from HigherOrderStream.delay
- Defined in stream/transforms.ts:295

drop

drop(n, options?): Stream<T, E>
Drop the first n items from the stream.
Parameters
- n: number
- Optional options: {
 atoms?: boolean;
 }
 - Optional atoms?: boolean
Returns Stream<T, E>
Inherited from HigherOrderStream.drop
- Defined in stream/transforms.ts:268

filter

filter(condition): Stream<T, E>
Filter over each value in the stream.
Parameters
- condition: ((value) => unknown)
 - - (value): unknown
 - Parameters
 value: T
 Returns unknown
Returns Stream<T, E>
Inherited from HigherOrderStream.filter
- Defined in stream/transforms.ts:155

inspect

inspect(): Stream<T, E>
Inspect every atom that is emitted through the stream.

Returns Stream<T, E>
Inherited from HigherOrderStream.inspect
- Defined in stream/transforms.ts:138

map

map(cb): Stream<U, E>
Map over each value in the stream.
Type Parameters
- U
Parameters
- cb: ((value) => MaybePromise<MaybeAtom<U, E>>)
 - - (value): MaybePromise<MaybeAtom<U, E>>
 - Parameters
 value: T
 Returns MaybePromise<MaybeAtom<U, E>>
Returns Stream<U, E>
Inherited from HigherOrderStream.map
- Defined in stream/transforms.ts:54

mapError

mapError<F>(cb): Stream<T, F>
Map over each error in the stream.
Type Parameters
- F
Parameters
- cb: ((error) => MaybePromise<MaybeAtom<T, F>>)
 - - (error): MaybePromise<MaybeAtom<T, F>>
 - Parameters
 error: E
 Returns MaybePromise<MaybeAtom<T, F>>
Returns Stream<T, F>
Inherited from HigherOrderStream.mapError
- Defined in stream/transforms.ts:73

mapException

mapException(cb): Stream<T, E>
Map over each exception in the stream.
Parameters
- cb: ((error) => MaybePromise<MaybeAtom<T, E>>)
 - - (error): MaybePromise<MaybeAtom<T, E>>
 - Parameters
 error: unknown
 Returns MaybePromise<MaybeAtom<T, E>>
Returns Stream<T, E>
Inherited from HigherOrderStream.mapException
- Defined in stream/transforms.ts:92

mapUnknown

mapUnknown(cb): Stream<T, E>
Parameters
- cb: ((error) => MaybePromise<MaybeAtom<T, E>>)
 - - (error): MaybePromise<MaybeAtom<T, E>>
 - Parameters
 error: unknown
 Returns MaybePromise<MaybeAtom<T, E>>
Returns Stream<T, E>
Deprecated
use mapException instead
Inherited from HigherOrderStream.mapUnknown
- Defined in stream/transforms.ts:110

take

take(n, options?): Stream<T, E>
Return a stream containing the first n values. If options.atoms is true, then the first n atoms rather than values will be emitted.
Parameters
- n: number
- Optional options: {
 atoms?: boolean;
 }
 - Optional atoms?: boolean
 If enabled, first n atoms will be counted, otherwise values.
Returns Stream<T, E>
Inherited from HigherOrderStream.take
- Defined in stream/transforms.ts:239

tap

tap(cb): Stream<T, E>
Run a callback for each value in the stream, ideal for side effects on stream items.
Parameters
- cb: ((value) => unknown)
 - - (value): unknown
 - Parameters
 value: T
 Returns unknown
Returns Stream<T, E>
Inherited from HigherOrderStream.tap
- Defined in stream/transforms.ts:119

Transforms

reduce

reduce(cb, memo): Stream<U, E>
Operate on each item in the stream, reducing it into a single value. The resulting value is returned in its own stream.
Type Parameters
- U
Parameters
- cb: ((memo, value) => MaybePromise<MaybeAtom<U, E>>)
 - - (memo, value): MaybePromise<MaybeAtom<U, E>>
 - Parameters
 memo: U
 value: T
 Returns MaybePromise<MaybeAtom<U, E>>
- memo: U
Returns Stream<U, E>
Inherited from HigherOrderStream.reduce
- Defined in stream/transforms.ts:207

Class Stream<T, E>

Type Parameters

T

E

Hierarchy

Index

Constructors

Properties

Methods

Atom

Consumption

Creation

Higher Order

Transform

Transforms

Constructors

constructor

Type Parameters

T

E

Parameters

stream: Readable

Returns Stream<T, E>

Properties

Protected stackTrace

Protected stream

Protected traceComplete

Static StreamEnd

Static WindpipeConsumptionError

Methods

batch

Parameters

options: { byBucket?: ((value) => string | number); n?: number; timeout?: number; yieldEmpty?: boolean; yieldRemaining?: boolean; }

Optional byBucket?: ((value) => string | number)

Parameters

value: T

Returns string | number

Optional n?: number

Optional timeout?: number

Optional yieldEmpty?: boolean

Optional yieldRemaining?: boolean

Returns Stream<T[], E>

exhaust

Returns Promise<void>

Protected getTrace

Returns string[]

onFirst

Parameters

callback: (() => void)

Returns void

Optional options: { atom?: boolean; } = {}

Optional atom?: boolean

Returns Stream<T, E>

onLast

Parameters

callback: (() => void)

Returns void

Optional options: { atom?: boolean; } = {}

Optional atom?: boolean

Returns Stream<T, E>

single

Parameters

options: { atom: true; optional: true; }

atom: true

optional: true

Returns Promise<undefined | Atom<T, E>>

Note

Parameters

options: { atom: true; optional?: false; }

atom: true

Optional optional?: false

Returns Promise<Atom<T, E>>

Parameters

options: { atom?: false; optional: true; }

Optional atom?: false

optional: true

Returns Promise<undefined | T>

Parameters

Optional options: { atom?: false; optional?: false; }

Optional atom?: false

`Protected` stackTrace

`Protected` stream

`Protected` traceComplete

`Static` StreamEnd

`Static` WindpipeConsumptionError

options: {
byBucket?: ((value) => string | number);
n?: number;
timeout?: number;
yieldEmpty?: boolean;
yieldRemaining?: boolean;
}

`Optional` byBucket?: ((value) => string | number)

`Optional` n?: number

`Optional` timeout?: number

`Optional` yieldEmpty?: boolean

`Optional` yieldRemaining?: boolean

`Protected` getTrace

`Optional` options: {
atom?: boolean;
} = {}

`Optional` atom?: boolean

`Optional` options: {
atom?: boolean;
} = {}

`Optional` atom?: boolean

options: {
atom: true;
optional: true;
}

options: {
atom: true;
optional?: false;
}

`Optional` optional?: false

options: {
atom?: false;
optional: true;
}

`Optional` atom?: false

`Optional` options: {
atom?: false;
optional?: false;
}

`Optional` atom?: false

`Optional` optional?: false

`Protected` trace

`Static` writable

Returns {
stream: Stream<T, E>;
writable: Writable;
}

`Static` error

`Static` exception

`Static` isError

`Static` isException

`Static` isOk

`Static` isUnknown

`Static` ok

`Static` unknown