Class AsyncIterable<T>`Abstract`

This class serves as the base for all operations which support [Symbol.asyncIterator].

Type Parameters

Hierarchy

AsyncIterable

Implements

AsyncIterable<T>

Index

Constructors

constructor

Methods

[asyncIterator] forEach pipe pipeThrough pipeTo tee as from

Constructors

constructor

new AsyncIterable<T>(): AsyncIterable<T>
Type Parameters
- T
Returns AsyncIterable<T>

Properties

average

average: {
(this, options?): Promise<number>;
<TSource>(this, options?): Promise<number>;
}

Type declaration

- (this, options?): Promise<number>
- Parameters
  - this: AsyncIterable<number>
  - Optional options: MathOptions<number>
  Returns Promise<number>
- <TSource>(this, options?): Promise<number>
- Type Parameters
  - TSource
  Parameters
  - this: AsyncIterable<TSource>
  - Optional options: MathOptions<TSource>
  Returns Promise<number>

batch

batch: {}

Type declaration

buffer

buffer: {}

Type declaration

catchError

catchError: {}

Type declaration

combineLatest

combineLatest: {
    <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>;
    <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>;
    <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>;
    <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>;
    <T>(this, ...sources): AsyncIterable<T[]>;
}

Type declaration

- <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>
- Type Parameters
  - T
  - T2
  - T3
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  Returns AsyncIterable<[T, T2, T3]>
- <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  - source4: AsyncIterable<T4>
  Returns AsyncIterable<[T, T2, T3, T4]>
- <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  - T5
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  - source4: AsyncIterable<T4>
  - source5: AsyncIterable<T5>
  Returns AsyncIterable<[T, T2, T3, T4, T5]>
- <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  - T5
  - T6
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  - source4: AsyncIterable<T4>
  - source5: AsyncIterable<T5>
  - source6: AsyncIterable<T6>
  Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>
- <T>(this, ...sources): AsyncIterable<T[]>
- Type Parameters
  - T
  Parameters
  - this: AsyncIterable<T>
  - Rest ...sources: AsyncIterable<T>[]
  Returns AsyncIterable<T[]>

concat

concat: {}

Type declaration

concatAll

concatAll: {}

Type declaration

concatMap

concatMap: {}

Type declaration

count

count: {}

Type declaration

debounce

debounce: {}

Type declaration

defaultIfEmpty

defaultIfEmpty: {}

Type declaration

delay

delay: (<TSource>(this, dueTime) => AsyncIterable<TSource>)

Type declaration

- <TSource>(this, dueTime): AsyncIterable<TSource>
- Type Parameters
  - TSource
  Parameters
  - this: AsyncIterable<TSource>
  - dueTime: number
  Returns AsyncIterable<TSource>

delayEach

delayEach: (<TSource>(this, dueTime) => AsyncIterable<TSource>)

Type declaration

- <TSource>(this, dueTime): AsyncIterable<TSource>
- Type Parameters
  - TSource
  Parameters
  - this: AsyncIterable<TSource>
  - dueTime: number
  Returns AsyncIterable<TSource>

distinct

distinct: {}

Type declaration

distinctUntilChanged

distinctUntilChanged: {}

Type declaration

doWhile

doWhile: {}

Type declaration

elementAt

elementAt: {}

Type declaration

endWith

endWith: {}

Type declaration

every

every: {}

Type declaration

except

except: {}

Type declaration

expand

expand: {}

Type declaration

filter

filter: (<T>(this, predicate, thisArg?) => AsyncIterable<T>)

Type declaration

- <T>(this, predicate, thisArg?): AsyncIterable<T>
- Type Parameters
  - T
  Parameters
  - this: AsyncIterable<T>
  - predicate: ((value, index, signal?) => boolean | Promise<boolean>)
    - (value, index, signal?): boolean | Promise<boolean>
      
      Parameters
      
      value: T
      
      index: number
      
      Optional signal: AbortSignal
      
      Returns boolean | Promise<boolean>
  - Optional thisArg: any
  Returns AsyncIterable<T>

finalize

finalize: {}

Type declaration

find

find: {}

Type declaration

findIndex

findIndex: {}

Type declaration

first

first: {}

Type declaration

flat

flat: {}

Type declaration

flatMap

flatMap: {}

Type declaration

forkJoin

forkJoin: {
    <T, T2, T3>(this, source2, source3): Promise<[T, T2, T3] | undefined>;
    <T, T2, T3, T4>(this, source2, source3, source4): Promise<[T, T2, T3, T4] | undefined>;
    <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): Promise<[T, T2, T3, T4, T5] | undefined>;
    <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): Promise<[T, T2, T3, T4, T5, T6] | undefined>;
    <T>(this, ...sources): Promise<T[] | undefined>;
}

Type declaration

- <T, T2, T3>(this, source2, source3): Promise<[T, T2, T3] | undefined>
- Type Parameters
  - T
  - T2
  - T3
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  Returns Promise<[T, T2, T3] | undefined>
- <T, T2, T3, T4>(this, source2, source3, source4): Promise<[T, T2, T3, T4] | undefined>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  - source4: AsyncIterable<T4>
  Returns Promise<[T, T2, T3, T4] | undefined>
- <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): Promise<[T, T2, T3, T4, T5] | undefined>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  - T5
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  - source4: AsyncIterable<T4>
  - source5: AsyncIterable<T5>
  Returns Promise<[T, T2, T3, T4, T5] | undefined>
- <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): Promise<[T, T2, T3, T4, T5, T6] | undefined>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  - T5
  - T6
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  - source4: AsyncIterable<T4>
  - source5: AsyncIterable<T5>
  - source6: AsyncIterable<T6>
  Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>
- <T>(this, ...sources): Promise<T[] | undefined>
- Type Parameters
  - T
  Parameters
  - this: AsyncIterable<T>
  - Rest ...sources: AsyncIterable<T>[]
  Returns Promise<T[] | undefined>

groupBy

groupBy: {
<TSource, TKey>(this, keySelector): AsyncIterable<GroupedAsyncIterable<TKey, TSource>>;
<TSource, TKey, TValue>(this, keySelector, elementSelector?): AsyncIterable<GroupedAsyncIterable<TKey, TValue>>;
}

Type declaration

- <TSource, TKey>(this, keySelector): AsyncIterable<GroupedAsyncIterable<TKey, TSource>>
- Type Parameters
  - TSource
  - TKey
  Parameters
  - this: AsyncIterable<TSource>
  - keySelector: ((value, signal?) => TKey | Promise<TKey>)
    - (value, signal?): TKey | Promise<TKey>
      
      Parameters
      
      value: TSource
      
      Optional signal: AbortSignal
      
      Returns TKey | Promise<TKey>
  Returns AsyncIterable<GroupedAsyncIterable<TKey, TSource>>
- <TSource, TKey, TValue>(this, keySelector, elementSelector?): AsyncIterable<GroupedAsyncIterable<TKey, TValue>>
- Type Parameters
  - TSource
  - TKey
  - TValue
  Parameters
  - this: AsyncIterable<TSource>
  - keySelector: ((value, signal?) => TKey | Promise<TKey>)
    - (value, signal?): TKey | Promise<TKey>
      
      Parameters
      
      value: TSource
      
      Optional signal: AbortSignal
      
      Returns TKey | Promise<TKey>
  - Optional elementSelector: ((value, signal?) => TValue | Promise<TValue>)
    - (value, signal?): TValue | Promise<TValue>
      
      Parameters
      
      value: TSource
      
      Optional signal: AbortSignal
      
      Returns TValue | Promise<TValue>
  Returns AsyncIterable<GroupedAsyncIterable<TKey, TValue>>

groupJoin

groupJoin: {}

Type declaration

ignoreElements

ignoreElements: {}

Type declaration

includes

includes: {}

Type declaration

innerJoin

innerJoin: {}

Type declaration

intersect

intersect: {}

Type declaration

isEmpty

isEmpty: {}

Type declaration

last

last: {}

Type declaration

map

map: {}

Type declaration

max

max: (<TSource, TResult>(this, options?) => Promise<TResult>)

Type declaration

- <TSource, TResult>(this, options?): Promise<TResult>
- Type Parameters
  - TSource
  - TResult = TSource
  Parameters
  - this: AsyncIterable<TSource>
  - Optional options: ExtremaOptions<TSource, TResult>
  Returns Promise<TResult>

maxBy

maxBy: {}

Type declaration

memoize

memoize: {
<T>(this, readerCount?): AsyncIterable<T>;
<T, R>(this, readerCount?, selector?): AsyncIterable<R>;
}

Type declaration

- <T>(this, readerCount?): AsyncIterable<T>
- Type Parameters
  - T
  Parameters
  - this: AsyncIterable<T>
  - Optional readerCount: number
  Returns AsyncIterable<T>
- <T, R>(this, readerCount?, selector?): AsyncIterable<R>
- Type Parameters
  - T
  - R
  Parameters
  - this: AsyncIterable<T>
  - Optional readerCount: number
  - Optional selector: ((value, signal?) => AsyncIterable<R>)
    - (value, signal?): AsyncIterable<R>
      
      Parameters
      
      value: AsyncIterable<T>
      
      Optional signal: AbortSignal
      
      Returns AsyncIterable<R>
  Returns AsyncIterable<R>

merge

merge: {}

Type declaration

mergeAll

mergeAll: {}

Type declaration

min

min: (<TSource, TResult>(this, options?) => Promise<TResult>)

Type declaration

- <TSource, TResult>(this, options?): Promise<TResult>
- Type Parameters
  - TSource
  - TResult = TSource
  Parameters
  - this: AsyncIterable<TSource>
  - Optional options: ExtremaOptions<TSource, TResult>
  Returns Promise<TResult>

minBy

minBy: {}

Type declaration

onErrorResumeNext

onErrorResumeNext: {}

Type declaration

orderBy

orderBy: {}

Type declaration

orderByDescending

orderByDescending: {}

Type declaration

pairwise

pairwise: {}

Type declaration

pluck

pluck: {}

Type declaration

publish

publish: {
<TSource>(this): AsyncIterable<TSource>;
<TSource, TResult>(this, selector?): AsyncIterable<TResult>;
}

Type declaration

- <TSource>(this): AsyncIterable<TSource>
- Type Parameters
  - TSource
  Parameters
  - this: AsyncIterable<TSource>
  Returns AsyncIterable<TSource>
- <TSource, TResult>(this, selector?): AsyncIterable<TResult>
- Type Parameters
  - TSource
  - TResult
  Parameters
  - this: AsyncIterable<TSource>
  - Optional selector: ((value) => AsyncIterable<TResult>)
    - (value): AsyncIterable<TResult>
      
      Parameters
      
      value: AsyncIterable<TSource>
      
      Returns AsyncIterable<TResult>
  Returns AsyncIterable<TResult>

reduce

reduce: {}

Type declaration

reduceRight

reduceRight: {}

Type declaration

repeat

repeat: {}

Type declaration

retry

retry: {}

Type declaration

reverse

reverse: {}

Type declaration

scan

scan: {}

Type declaration

scanRight

scanRight: {}

Type declaration

sequenceEqual

sequenceEqual: {}

Type declaration

share: {
<TSource>(this): AsyncIterable<TSource>;
<TSource, TResult>(this, selector?): AsyncIterable<TResult>;
}

Type declaration

- <TSource>(this): AsyncIterable<TSource>
- Type Parameters
  - TSource
  Parameters
  - this: AsyncIterable<TSource>
  Returns AsyncIterable<TSource>
- <TSource, TResult>(this, selector?): AsyncIterable<TResult>
- Type Parameters
  - TSource
  - TResult
  Parameters
  - this: AsyncIterable<TSource>
  - Optional selector: ((value) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>)
    - (value): AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>
      
      Parameters
      
      value: AsyncIterable<TSource>
      
      Returns AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>
  Returns AsyncIterable<TResult>

single

single: {}

Type declaration

skip

skip: {}

Type declaration

skipLast

skipLast: {}

Type declaration

skipUntil

skipUntil: {}

Type declaration

skipWhile

skipWhile: (<T>(this, predicate) => AsyncIterable<T>)

Type declaration

- <T>(this, predicate): AsyncIterable<T>
- Type Parameters
  - T
  Parameters
  - this: AsyncIterable<T>
  - predicate: ((value, index, signal?) => boolean | Promise<boolean>)
    - (value, index, signal?): boolean | Promise<boolean>
      
      Parameters
      
      value: T
      
      index: number
      
      Optional signal: AbortSignal
      
      Returns boolean | Promise<boolean>
  Returns AsyncIterable<T>

slice

slice: {}

Type declaration

some

some: {}

Type declaration

startWith

startWith: {}

Type declaration

sum

sum: {
(this, options?): Promise<number>;
<T>(this, options?): Promise<number>;
}

Type declaration

- (this, options?): Promise<number>
- Parameters
  - this: AsyncIterable<number>
  - Optional options: MathOptions<number>
  Returns Promise<number>
- <T>(this, options?): Promise<number>
- Type Parameters
  - T
  Parameters
  - this: AsyncIterable<T>
  - Optional options: MathOptions<T>
  Returns Promise<number>

switchAll

switchAll: {}

Type declaration

switchMap

switchMap: {}

Type declaration

take

take: {}

Type declaration

takeLast

takeLast: {}

Type declaration

takeUntil

takeUntil: {}

Type declaration

takeWhile

takeWhile: (<T>(this, predicate) => AsyncIterable<T>)

Type declaration

- <T>(this, predicate): AsyncIterable<T>
- Type Parameters
  - T
  Parameters
  - this: AsyncIterable<T>
  - predicate: ((value, index, signal?) => boolean | Promise<boolean>)
    - (value, index, signal?): boolean | Promise<boolean>
      
      Parameters
      
      value: T
      
      index: number
      
      Optional signal: AbortSignal
      
      Returns boolean | Promise<boolean>
  Returns AsyncIterable<T>

tap

tap: {}

Type declaration

throttle

throttle: {}

Type declaration

toArray

toArray: {}

Type declaration

toDOMStream

toDOMStream: {
<T>(this, options): ReadableStream<Uint8Array>;
<T>(this, options): ReadableStream<Uint8Array>;
}

Type declaration

- <T>(this, options): ReadableStream<Uint8Array>
- Type Parameters
  - T
  Parameters
  - this: AsyncIterable<T>
  - options: ReadableBYOBStreamOptions<Uint8Array>
  Returns ReadableStream<Uint8Array>
- <T>(this, options): ReadableStream<Uint8Array>
- Type Parameters
  - T
  Parameters
  - this: AsyncIterable<T>
  - options: ReadableByteStreamOptions<Uint8Array>
  Returns ReadableStream<Uint8Array>

toMap

toMap: (<TSource, TKey, TElement>(this, options) => Promise<Map<TKey, TElement | TSource>>)

Type declaration

- <TSource, TKey, TElement>(this, options): Promise<Map<TKey, TElement | TSource>>
- Type Parameters
  - TSource
  - TKey
  - TElement = TSource
  Parameters
  - this: AsyncIterable<TSource>
  - options: ToMapOptions<TSource, TKey, TElement>
  Returns Promise<Map<TKey, TElement | TSource>>

toNodeStream

toNodeStream: {
<TSource>(this, options): AsyncIterableReadable<TSource>;
<TSource>(this, options): AsyncIterableReadable<TSource>;
}

Type declaration

- <TSource>(this, options): AsyncIterableReadable<TSource>
- Type Parameters
  - TSource
  Parameters
  - this: AsyncIterable<TSource>
  - options: ReadableOptions & {
    objectMode: true;
    }
  Returns AsyncIterableReadable<TSource>
- <TSource>(this, options): AsyncIterableReadable<TSource>
- Type Parameters
  - TSource extends BufferLike
  Parameters
  - this: AsyncIterable<TSource>
  - options: ReadableOptions & {
    objectMode: false;
    }
  Returns AsyncIterableReadable<TSource>

toObservable

toObservable: {}

Type declaration

toSet

toSet: {}

Type declaration

union

union: {}

Type declaration

withLatestFrom

withLatestFrom: {
    <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>;
    <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>;
    <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>;
    <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>;
    <T>(this, ...sources): AsyncIterable<T[]>;
}

Type declaration

- <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>
- Type Parameters
  - T
  - T2
  - T3
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  Returns AsyncIterable<[T, T2, T3]>
- <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  - source4: AsyncIterable<T4>
  Returns AsyncIterable<[T, T2, T3, T4]>
- <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  - T5
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  - source4: AsyncIterable<T4>
  - source5: AsyncIterable<T5>
  Returns AsyncIterable<[T, T2, T3, T4, T5]>
- <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  - T5
  - T6
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  - source4: AsyncIterable<T4>
  - source5: AsyncIterable<T5>
  - source6: AsyncIterable<T6>
  Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>
- <T>(this, ...sources): AsyncIterable<T[]>
- Type Parameters
  - T
  Parameters
  - this: AsyncIterable<T>
  - Rest ...sources: AsyncIterable<T>[]
  Returns AsyncIterable<T[]>

zip

zip: {
    <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>;
    <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>;
    <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>;
    <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>;
    <T>(this, ...sources): AsyncIterable<T[]>;
}

Type declaration

- <T, T2, T3>(this, source2, source3): AsyncIterable<[T, T2, T3]>
- Type Parameters
  - T
  - T2
  - T3
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  Returns AsyncIterable<[T, T2, T3]>
- <T, T2, T3, T4>(this, source2, source3, source4): AsyncIterable<[T, T2, T3, T4]>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  - source4: AsyncIterable<T4>
  Returns AsyncIterable<[T, T2, T3, T4]>
- <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): AsyncIterable<[T, T2, T3, T4, T5]>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  - T5
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  - source4: AsyncIterable<T4>
  - source5: AsyncIterable<T5>
  Returns AsyncIterable<[T, T2, T3, T4, T5]>
- <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): AsyncIterable<[T, T2, T3, T4, T5, T6]>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  - T5
  - T6
  Parameters
  - this: AsyncIterable<T>
  - source2: AsyncIterable<T2>
  - source3: AsyncIterable<T3>
  - source4: AsyncIterable<T4>
  - source5: AsyncIterable<T5>
  - source6: AsyncIterable<T6>
  Returns AsyncIterable<[T, T2, T3, T4, T5, T6]>
- <T>(this, ...sources): AsyncIterable<T[]>
- Type Parameters
  - T
  Parameters
  - this: AsyncIterable<T>
  - Rest ...sources: AsyncIterable<T>[]
  Returns AsyncIterable<T[]>

Methods

`Abstract` [asyncIterator]

[asyncIterator](signal?): AsyncIterator<T, any, undefined>
Parameters
- Optional signal: AbortSignal
Returns AsyncIterator<T, any, undefined>
Implementation of AsyncIterable.[asyncIterator]
- Defined in asynciterable/asynciterablex.ts:22

forEach

forEach(projection, thisArg?, signal?): Promise<void>
Parameters
- projection: ((value, index, signal?) => void | Promise<void>)
  - - (value, index, signal?): void | Promise<void>
    - Parameters
      
      value: T
      
      index: number
      
      Optional signal: AbortSignal
      
      Returns void | Promise<void>
- Optional thisArg: any
- Optional signal: AbortSignal
Returns Promise<void>

Nocollapse
- Defined in asynciterable/asynciterablex.ts:25

pipe

pipe<R>(...operations): R
Type Parameters
- R
Parameters
- Rest ...operations: UnaryFunction<AsyncIterable<T>, R>[]
Returns R

Nocollapse
- Defined in asynciterable/asynciterablex.ts:39
pipe<R>(...operations): AsyncIterable<R>
Type Parameters
- R
Parameters
- Rest ...operations: OperatorAsyncFunction<T, R>[]
Returns AsyncIterable<R>
- Defined in asynciterable/asynciterablex.ts:40
pipe<R>(writable, options?): R
Type Parameters
- R extends WritableStream
Parameters
- writable: R
- Optional options: {
  end?: boolean;
  }
  - Optional end?: boolean
Returns R
- Defined in asynciterable/asynciterablex.ts:41
pipe(): AsyncIterable<T>
Returns AsyncIterable<T>
- Defined in asynciterable/asynciterablex.ts:385
pipe<A>(op1): AsyncIterable<A>
Type Parameters
- A
Parameters
- op1: OperatorAsyncFunction<T, A>
Returns AsyncIterable<A>
- Defined in asynciterable/asynciterablex.ts:386
pipe<A, B>(op1, op2): AsyncIterable<B>
Type Parameters
- A
- B
Parameters
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
Returns AsyncIterable<B>
- Defined in asynciterable/asynciterablex.ts:387
pipe<A, B, C>(op1, op2, op3): AsyncIterable<C>
Type Parameters
- A
- B
- C
Parameters
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
Returns AsyncIterable<C>
- Defined in asynciterable/asynciterablex.ts:391
pipe<A, B, C, D>(op1, op2, op3, op4): AsyncIterable<D>
Type Parameters
- A
- B
- C
- D
Parameters
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
- op4: OperatorAsyncFunction<C, D>
Returns AsyncIterable<D>
- Defined in asynciterable/asynciterablex.ts:396
pipe<A, B, C, D, E>(op1, op2, op3, op4, op5): AsyncIterable<E>
Type Parameters
- A
- B
- C
- D
- E
Parameters
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
- op4: OperatorAsyncFunction<C, D>
- op5: OperatorAsyncFunction<D, E>
Returns AsyncIterable<E>
- Defined in asynciterable/asynciterablex.ts:402
pipe<A, B, C, D, E, F>(op1, op2, op3, op4, op5, op6): AsyncIterable<F>
Type Parameters
- A
- B
- C
- D
- E
- F
Parameters
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
- op4: OperatorAsyncFunction<C, D>
- op5: OperatorAsyncFunction<D, E>
- op6: OperatorAsyncFunction<E, F>
Returns AsyncIterable<F>
- Defined in asynciterable/asynciterablex.ts:409
pipe<A, B, C, D, E, F, G>(op1, op2, op3, op4, op5, op6, op7): AsyncIterable<G>
Type Parameters
- A
- B
- C
- D
- E
- F
- G
Parameters
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
- op4: OperatorAsyncFunction<C, D>
- op5: OperatorAsyncFunction<D, E>
- op6: OperatorAsyncFunction<E, F>
- op7: OperatorAsyncFunction<F, G>
Returns AsyncIterable<G>
- Defined in asynciterable/asynciterablex.ts:417
pipe<A, B, C, D, E, F, G, H>(op1, op2, op3, op4, op5, op6, op7, op8): AsyncIterable<H>
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
Parameters
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
- op4: OperatorAsyncFunction<C, D>
- op5: OperatorAsyncFunction<D, E>
- op6: OperatorAsyncFunction<E, F>
- op7: OperatorAsyncFunction<F, G>
- op8: OperatorAsyncFunction<G, H>
Returns AsyncIterable<H>
- Defined in asynciterable/asynciterablex.ts:426
pipe<A, B, C, D, E, F, G, H, I>(op1, op2, op3, op4, op5, op6, op7, op8, op9): AsyncIterable<I>
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
Parameters
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
- op4: OperatorAsyncFunction<C, D>
- op5: OperatorAsyncFunction<D, E>
- op6: OperatorAsyncFunction<E, F>
- op7: OperatorAsyncFunction<F, G>
- op8: OperatorAsyncFunction<G, H>
- op9: OperatorAsyncFunction<H, I>
Returns AsyncIterable<I>
- Defined in asynciterable/asynciterablex.ts:436
pipe(...operations): AsyncIterable<any>
Parameters
- Rest ...operations: OperatorAsyncFunction<any, any>[]
Returns AsyncIterable<any>
- Defined in asynciterable/asynciterablex.ts:447
pipe<A>(op1, options?): A
Type Parameters
- A extends WritableStream
Parameters
- op1: A
- Optional options: {
  end?: boolean;
  }
  - Optional end?: boolean
Returns A
- Defined in asynciterable/asynciterablex.ts:448

pipeThrough

pipeThrough<R>(duplex, options?): R
Type Parameters
- R extends ReadableStream<any>
Parameters
- duplex: {
  readable: R;
  writable: WritableStream<T>;
  }
  - readable: R
  - writable: WritableStream<T>
- Optional options: StreamPipeOptions
Returns R
- Defined in asynciterable/todomstream.ts:271

pipeTo

pipeTo(writable, options?): Promise<void>
Parameters
- writable: WritableStream<T>
- Optional options: StreamPipeOptions
Returns Promise<void>
- Defined in asynciterable/todomstream.ts:270

tee

tee(): [ReadableStream<T>, ReadableStream<T>]
Returns [ReadableStream<T>, ReadableStream<T>]
- Defined in asynciterable/todomstream.ts:269

`Static` as

as(source): AsyncIterable<string>
Converts an existing string into an async-iterable of characters.
Parameters
- source: string
  
  The string to convert to an async-iterable.
Returns AsyncIterable<string>
An async-iterable stream of characters from the source.
- Defined in asynciterable/asynciterablex.ts:83
as<T>(source): AsyncIterable<T>
Converts the AsyncIterable-like input or single element into an AsyncIterable.
Type Parameters
- T
  
  The type of elements in the async-iterable like sequence.
Parameters
- source: T | AsyncIterableInput<T>
  
  The async-iterable like input to convert to an async-iterable.
Returns AsyncIterable<T>
An async-iterable stream from elements in the async-iterable like sequence.
- Defined in asynciterable/asynciterablex.ts:91
as<T>(source): AsyncIterable<T>
Converts the single element into an async-iterable sequence.
Type Parameters
- T
  
  The type of the input to turn into an async-iterable sequence.
Parameters
- source: T
  
  The single element to turn into an async-iterable sequence.
Returns AsyncIterable<T>
An async-iterable sequence which contains the single element.
- Defined in asynciterable/asynciterablex.ts:99

`Static` from

from<TSource, TResult>(source, selector?, thisArg?): AsyncIterable<TResult>
Type Parameters
- TSource
- TResult = TSource
Parameters
- source: AsyncIterableInput<TSource>
- selector: ((value, index) => TResult | Promise<TResult>) = identityAsync
  - - (value, index): TResult | Promise<TResult>
    - Parameters
      
      value: TSource
      
      index: number
      
      Returns TResult | Promise<TResult>
- Optional thisArg: any
Returns AsyncIterable<TResult>

Nocollapse
- Defined in asynciterable/asynciterablex.ts:53

Class AsyncIterable<T>Abstract

Type Parameters

T

Hierarchy

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Type Parameters

T

Returns AsyncIterable<T>

Properties

average

Type declaration

Parameters

this: AsyncIterable<number>

Optional options: MathOptions<number>

Returns Promise<number>

Type Parameters

TSource

Parameters

this: AsyncIterable<TSource>

Optional options: MathOptions<TSource>

Returns Promise<number>

batch

Type declaration

buffer

Type declaration

catchError

Type declaration

combineLatest

Type declaration

Type Parameters

T

T2

T3

Parameters

this: AsyncIterable<T>

source2: AsyncIterable<T2>

source3: AsyncIterable<T3>

Returns AsyncIterable<[T, T2, T3]>

Type Parameters

T

T2

T3

T4

Parameters

this: AsyncIterable<T>

source2: AsyncIterable<T2>

source3: AsyncIterable<T3>

source4: AsyncIterable<T4>

Returns AsyncIterable<[T, T2, T3, T4]>

Type Parameters

T

T2

T3

T4

T5

Parameters

this: AsyncIterable<T>

source2: AsyncIterable<T2>

source3: AsyncIterable<T3>

source4: AsyncIterable<T4>

source5: AsyncIterable<T5>

Returns AsyncIterable<[T, T2, T3, T4, T5]>

Type Parameters

T

T2

T3

T4

T5

T6

Parameters

this: AsyncIterable<T>

source2: AsyncIterable<T2>

source3: AsyncIterable<T3>

source4: AsyncIterable<T4>

Class AsyncIterable<T>`Abstract`

`Optional` options: MathOptions<number>

`Optional` options: MathOptions<TSource>

`Rest` ...sources: AsyncIterable<T>[]

`Optional` signal: AbortSignal

`Optional` thisArg: any