Class Flu<T>

Type parameters

T

Hierarchy

Flu
- CbFlu

Implements

AsyncIterable<T>

Index

Methods

[asyncIterator]

[asyncIterator](): AsyncIterator<T, any, undefined>

Implementation of AsyncIterable.__@asyncIterator@22028
- Defined in flu.ts:12
Returns AsyncIterator<T, any, undefined>

Static empty

empty<T>(): Flu<T>

- Defined in flu.ts:16
Type parameters
- T
Returns Flu<T>

Static by

by<T>(iter: () => AsyncIterable<T>): Flu<T>

- Defined in flu.ts:20
Type parameters
- T
Parameters
- iter: () => AsyncIterable<T>
  - - (): AsyncIterable<T>
    - Returns AsyncIterable<T>
Returns Flu<T>

Static of

of<T>(...iter: T[]): Flu<T>

- Defined in flu.ts:24
Type parameters
- T
Parameters
- Rest ...iter: T[]
Returns Flu<T>

Static from

from<T>(iter: Iterable<T>): Flu<T>

- Defined in flu.ts:28
Type parameters
- T
Parameters
- iter: Iterable<T>
Returns Flu<T>

Static fromIter

fromIter<T>(iter: Iterable<T | Promise<T>>): Flu<T>

- Defined in flu.ts:32
Type parameters
- T
Parameters
- iter: Iterable<T | Promise<T>>
Returns Flu<T>

Static fromCallback

fromCallback<T>(): CbFlu<[T], T, never>
fromCallback<A, T, This>(map?: (...args: A) => T): CbFlu<A, T, This>

- Defined in flu.ts:36
Type parameters
- T
Returns CbFlu<[T], T, never>
- Defined in flu.ts:37
Type parameters
- A: unknown[]
- T = A[0]
- This = never
Parameters
- Optional map: (...args: A) => T
  - - (...args: A): T
    - Parameters
      - Rest ...args: A
      Returns T
Returns CbFlu<A, T, This>

Static to

to(to: number, step?: number): Flu<number>

- Defined in flu.ts:43
Create a Flu from a range starting from 0

Parameters
- to: number
- step: number = 1
Returns Flu<number>

Static range

range(from: number, to: number, step?: number): Flu<number>

- Defined in flu.ts:54
Create a Flu from a range

Parameters
- from: number
- to: number
- step: number = 1
Returns Flu<number>

collect

collect(): Promise<T[]>

- Defined in flu.ts:65
Returns Promise<T[]>

join

join(separator?: string): Promise<string>

- Defined in flu.ts:69
Parameters
- Optional separator: string
Returns Promise<string>

count

count(): Promise<number>

- Defined in flu.ts:73
Returns Promise<number>

isEmpty

isEmpty(): Promise<boolean>

- Defined in flu.ts:77
Returns Promise<boolean>

first

first(): Promise<Voidable<T>>

- Defined in flu.ts:81
Returns Promise<Voidable<T>>

firstO

firstO(): Promise<Option<T>>

- Defined in flu.ts:85
Returns Promise<Option<T>>

last

last(): Promise<Voidable<T>>

- Defined in flu.ts:89
Returns Promise<Voidable<T>>

lastO

lastO(): Promise<Option<T>>

- Defined in flu.ts:93
Returns Promise<Option<T>>

nth

nth(n: number): Promise<Voidable<T>>

- Defined in flu.ts:97
Parameters
- n: number
Returns Promise<Voidable<T>>

nthO

nthO(n: number): Promise<Option<T>>

- Defined in flu.ts:101
Parameters
- n: number
Returns Promise<Option<T>>

stepBy

stepBy(step: number): Flu<T>

- Defined in flu.ts:105
Parameters
- step: number
Returns Flu<T>

chain

chain(other: AsyncIterable<T> | Iterable<T>, ...more: (AsyncIterable<T> | Iterable<T>)[]): Flu<T>

- Defined in flu.ts:109
Parameters
- other: AsyncIterable<T> | Iterable<T>
- Rest ...more: (AsyncIterable<T> | Iterable<T>)[]
Returns Flu<T>

zip

zip<U>(other: AsyncIterable<U>): Flu<[T, U]>

- Defined in flu.ts:113
Type parameters
- U
Parameters
- other: AsyncIterable<U>
Returns Flu<[T, U]>

unzip

unzip(): Promise<[(T extends [A, any] | readonly [A, any] ? A : T extends R[] ? R : unknown)[], (T extends [any, B] | readonly [any, B] ? B : T extends R[] ? R : unknown)[]]>

- Defined in flu.ts:117
Returns Promise<[(T extends [A, any] | readonly [A, any] ? A : T extends R[] ? R : unknown)[], (T extends [any, B] | readonly [any, B] ? B : T extends R[] ? R : unknown)[]]>

map

map<R>(f: (v: T) => R): Flu<R>

- Defined in flu.ts:124
Type parameters
- R
Parameters
- f: (v: T) => R
  - - (v: T): R
    - Parameters
      - v: T
      Returns R
Returns Flu<R>

mapWait

mapWait<R>(f: (v: T) => R | PromiseLike<R>): Flu<R>

- Defined in flu.ts:128
Type parameters
- R
Parameters
- f: (v: T) => R | PromiseLike<R>
  - - (v: T): R | PromiseLike<R>
    - Parameters
      - v: T
      Returns R | PromiseLike<R>
Returns Flu<R>

fill

fill<R>(v: R): Flu<R>

- Defined in flu.ts:132
Type parameters
- R
Parameters
- v: R
Returns Flu<R>

forEach

forEach(f: (v: T) => unknown): Promise<void>

- Defined in flu.ts:136
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Promise<void>

run

run(): Promise<void>

- Defined in flu.ts:140
Returns Promise<void>

filter

filter<S>(f: (v: T) => v is S): Flu<S>
filter(f: (v: T) => unknown): Flu<T>

- Defined in flu.ts:144
Type parameters
- S
Parameters
- f: (v: T) => v is S
  - - (v: T): v is S
    - Parameters
      - v: T
      Returns v is S
Returns Flu<S>
- Defined in flu.ts:145
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Flu<T>

enumerate

enumerate(): Flu<[T, number]>

- Defined in flu.ts:150
Returns Flu<[T, number]>

indexed

indexed(): Flu<[number, T]>

- Defined in flu.ts:154
Returns Flu<[number, T]>

skip

skip(n: number): Flu<T>

- Defined in flu.ts:158
Parameters
- n: number
Returns Flu<T>

take

take(n: number): Flu<T>

- Defined in flu.ts:162
Parameters
- n: number
Returns Flu<T>

slice

slice(from: number, to: number): Flu<T>

- Defined in flu.ts:166
Parameters
- from: number
- to: number
Returns Flu<T>

sub

sub(from: number, count: number): Flu<T>

- Defined in flu.ts:170
Parameters
- from: number
- count: number
Returns Flu<T>

scan

scan<R>(init: R, f: (acc: R, val: T) => R): Flu<R>

- Defined in flu.ts:174
Type parameters
- R
Parameters
- init: R
- f: (acc: R, val: T) => R
  - - (acc: R, val: T): R
    - Parameters
      - acc: R
      - val: T
      Returns R
Returns Flu<R>

scanWait

scanWait<R>(init: R | PromiseLike<R>, f: (acc: R, val: T) => R | PromiseLike<R>): Flu<R>

- Defined in flu.ts:178
Type parameters
- R
Parameters
- init: R | PromiseLike<R>
- f: (acc: R, val: T) => R | PromiseLike<R>
  - - (acc: R, val: T): R | PromiseLike<R>
    - Parameters
      - acc: R
      - val: T
      Returns R | PromiseLike<R>
Returns Flu<R>

flatMap

flatMap<R>(f: (v: T) => AsyncIterable<R> | Iterable<R>): Flu<R>

- Defined in flu.ts:182
Type parameters
- R
Parameters
- f: (v: T) => AsyncIterable<R> | Iterable<R>
  - - (v: T): AsyncIterable<R> | Iterable<R>
    - Parameters
      - v: T
      Returns AsyncIterable<R> | Iterable<R>
Returns Flu<R>

flatten

flatten(): T extends AsyncIterable<R> ? Flu<R> : T extends Iterable<R> ? Flu<R> : never

- Defined in flu.ts:186
Returns T extends AsyncIterable<R> ? Flu<R> : T extends Iterable<R> ? Flu<R> : never

wait

wait(): T extends R | PromiseLike<R> ? Flu<R> : never

- Defined in flu.ts:190
Returns T extends R | PromiseLike<R> ? Flu<R> : never

also

also(f: (v: T) => unknown): Flu<T>

- Defined in flu.ts:194
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Flu<T>

fold

fold<R>(init: R, f: (acc: R, val: T) => R): Promise<R>

- Defined in flu.ts:198
Type parameters
- R
Parameters
- init: R
- f: (acc: R, val: T) => R
  - - (acc: R, val: T): R
    - Parameters
      - acc: R
      - val: T
      Returns R
Returns Promise<R>

foldWait

foldWait<R>(init: R | PromiseLike<R>, f: (acc: R, val: T) => R | PromiseLike<R>): Promise<R>

- Defined in flu.ts:202
Type parameters
- R
Parameters
- init: R | PromiseLike<R>
- f: (acc: R, val: T) => R | PromiseLike<R>
  - - (acc: R, val: T): R | PromiseLike<R>
    - Parameters
      - acc: R
      - val: T
      Returns R | PromiseLike<R>
Returns Promise<R>

reduce

reduce(f: (acc: T, val: T) => T): Promise<T>

- Defined in flu.ts:206
Parameters
- f: (acc: T, val: T) => T
  - - (acc: T, val: T): T
    - Parameters
      - acc: T
      - val: T
      Returns T
Returns Promise<T>

reduceWait

reduceWait(f: (acc: T, val: T) => T | PromiseLike<T>): Promise<T>

- Defined in flu.ts:210
Parameters
- f: (acc: T, val: T) => T | PromiseLike<T>
  - - (acc: T, val: T): T | PromiseLike<T>
    - Parameters
      - acc: T
      - val: T
      Returns T | PromiseLike<T>
Returns Promise<T>

all

all(f: (v: T) => unknown): Promise<boolean>

- Defined in flu.ts:214
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Promise<boolean>

any

any(f: (v: T) => unknown): Promise<boolean>

- Defined in flu.ts:218
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Promise<boolean>

find

find(f: (v: T) => unknown): Promise<Voidable<T>>

- Defined in flu.ts:222
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Promise<Voidable<T>>

position

position(f: (v: T) => unknown): Promise<number>

- Defined in flu.ts:226
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Promise<number>

indexOf

indexOf(v: T): Promise<number>

- Defined in flu.ts:230
Parameters
- v: T
Returns Promise<number>

indexOfWait

indexOfWait(v: T | PromiseLike<T>): Promise<number>

- Defined in flu.ts:234
Parameters
- v: T | PromiseLike<T>
Returns Promise<number>

max

max(): Promise<Voidable<T>>

- Defined in flu.ts:238
Returns Promise<Voidable<T>>

min

min(): Promise<Voidable<T>>

- Defined in flu.ts:242
Returns Promise<Voidable<T>>

merge

merge<U>(other: AsyncIterable<U>): Flu<T | U>

- Defined in flu.ts:246
Type parameters
- U
Parameters
- other: AsyncIterable<U>
Returns Flu<T | U>

delay

delay(ms?: Voidable<number>): Flu<T>
delay(f: (v: T) => unknown): Flu<T>
delay(ms: Voidable<number>, f: (v: T) => unknown): Flu<T>

- Defined in flu.ts:250
Parameters
- Optional ms: Voidable<number>
Returns Flu<T>
- Defined in flu.ts:251
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Flu<T>
- Defined in flu.ts:252
Parameters
- ms: Voidable<number>
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Flu<T>

retry

retry(count: number): Flu<T>
retry<E>(f: (err: E, count: number) => unknown): Flu<T>
retry<E>(cond: number | ((err: E, count: number) => unknown)): Flu<T>

- Defined in flu.ts:258
Parameters
- count: number
Returns Flu<T>
- Defined in flu.ts:259
Type parameters
- E = unknown
Parameters
- f: (err: E, count: number) => unknown
  - - (err: E, count: number): unknown
    - Parameters
      - err: E
      - count: number
      Returns unknown
Returns Flu<T>
- Defined in flu.ts:260
Type parameters
- E = unknown
Parameters
- cond: number | ((err: E, count: number) => unknown)
Returns Flu<T>

timestamp

timestamp(): Flu<[value: T, timestamp: number]>

- Defined in flu.ts:265
Returns Flu<[value: T, timestamp: number]>

throttle

throttle(ms: number): Flu<T>

- Defined in flu.ts:269
Parameters
- ms: number
Returns Flu<T>

debounce

debounce(ms: number): Flu<T>

- Defined in flu.ts:273
Parameters
- ms: number
Returns Flu<T>

audit

audit(ms: number): Flu<T>

- Defined in flu.ts:277
Parameters
- ms: number
Returns Flu<T>

buffer

buffer(n: number, mode?: "count" | "time"): Flu<T[]>

- Defined in flu.ts:281
Parameters
- n: number
- mode: "count" | "time" = 'count'
Returns Flu<T[]>

break

break(): Flu<T>

- Defined in flu.ts:285
Returns Flu<T>

breakBy

breakBy(f: (v: T) => unknown): Flu<T>

- Defined in flu.ts:289
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Flu<T>

takeIf

takeIf(f: (v: T) => unknown): Flu<T>

- Defined in flu.ts:293
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Flu<T>

startBy

startBy(f: (v: T) => unknown): Flu<T>

- Defined in flu.ts:297
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Flu<T>

skipIf

skipIf(f: (v: T) => unknown): Flu<T>

- Defined in flu.ts:301
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Flu<T>

drop

drop(): Flu<void>

- Defined in flu.ts:305
Returns Flu<void>

forEnd

forEnd(): Flu<any>

- Defined in flu.ts:309
Returns Flu<any>

breakAt

breakAt(f: (v: T) => unknown): Flu<T>
breakAt(single: PromiseLike<unknown>): Flu<T>
breakAt(single: AsyncIterable<unknown>): Flu<T>
breakAt(single: PromiseLike<unknown> | AsyncIterable<unknown> | ((v: T) => unknown)): Flu<T>

- Defined in flu.ts:313
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Flu<T>
- Defined in flu.ts:314
Parameters
- single: PromiseLike<unknown>
Returns Flu<T>
- Defined in flu.ts:315
Parameters
- single: AsyncIterable<unknown>
Returns Flu<T>
- Defined in flu.ts:316
Parameters
- single: PromiseLike<unknown> | AsyncIterable<unknown> | ((v: T) => unknown)
Returns Flu<T>

takeUntil

takeUntil(single: PromiseLike<unknown>): Flu<T>
takeUntil(single: AsyncIterable<unknown>): Flu<T>
takeUntil(single: PromiseLike<unknown> | AsyncIterable<unknown>): Flu<T>

- Defined in flu.ts:322
Parameters
- single: PromiseLike<unknown>
Returns Flu<T>
- Defined in flu.ts:323
Parameters
- single: AsyncIterable<unknown>
Returns Flu<T>
- Defined in flu.ts:324
Parameters
- single: PromiseLike<unknown> | AsyncIterable<unknown>
Returns Flu<T>

startAt

startAt(f: (v: T) => unknown): Flu<T>
startAt(single: PromiseLike<unknown>): Flu<T>
startAt(single: AsyncIterable<unknown>): Flu<T>
startAt(single: PromiseLike<unknown> | AsyncIterable<unknown> | ((v: T) => unknown)): Flu<T>

- Defined in flu.ts:329
Parameters
- f: (v: T) => unknown
  - - (v: T): unknown
    - Parameters
      - v: T
      Returns unknown
Returns Flu<T>
- Defined in flu.ts:330
Parameters
- single: PromiseLike<unknown>
Returns Flu<T>
- Defined in flu.ts:331
Parameters
- single: AsyncIterable<unknown>
Returns Flu<T>
- Defined in flu.ts:332
Parameters
- single: PromiseLike<unknown> | AsyncIterable<unknown> | ((v: T) => unknown)
Returns Flu<T>

skipUntil

skipUntil(single: PromiseLike<unknown>): Flu<T>
skipUntil(single: AsyncIterable<unknown>): Flu<T>
skipUntil(single: PromiseLike<unknown> | AsyncIterable<unknown>): Flu<T>

- Defined in flu.ts:338
Parameters
- single: PromiseLike<unknown>
Returns Flu<T>
- Defined in flu.ts:339
Parameters
- single: AsyncIterable<unknown>
Returns Flu<T>
- Defined in flu.ts:340
Parameters
- single: PromiseLike<unknown> | AsyncIterable<unknown>
Returns Flu<T>

push

push(...items: T[]): Flu<T>

- Defined in flu.ts:345
Parameters
- Rest ...items: T[]
Returns Flu<T>

unshift

unshift(...items: T[]): Flu<T>

- Defined in flu.ts:349
Parameters
- Rest ...items: T[]
Returns Flu<T>

as

as<U>(): Flu<U>

- Defined in flu.ts:353
Type parameters
- U
Returns Flu<U>

groupBy

groupBy<K>(keyf: (v: T) => K): Flu<[K, T[]]>
groupBy<K, V>(keyf: (v: T) => K, valf: (v: T) => V): Flu<[K, V[]]>

- Defined in flu.ts:357
Type parameters
- K
Parameters
- keyf: (v: T) => K
  - - (v: T): K
    - Parameters
      - v: T
      Returns K
Returns Flu<[K, T[]]>
- Defined in flu.ts:358
Type parameters
- K
- V
Parameters
- keyf: (v: T) => K
  - - (v: T): K
    - Parameters
      - v: T
      Returns K
- valf: (v: T) => V
  - - (v: T): V
    - Parameters
      - v: T
      Returns V
Returns Flu<[K, V[]]>

toArray

toArray(): Promise<T[]>

- Defined in flu.ts:363
Returns Promise<T[]>

toSet

toSet(): Promise<Set<T>>

- Defined in flu.ts:367
Returns Promise<Set<T>>

toMap

toMap(): Promise<T extends [K, V] ? Map<K, V> : never>

- Defined in flu.ts:371
Returns Promise<T extends [K, V] ? Map<K, V> : never>

Constructors

constructor

new Flu<T>(iter: () => AsyncIterable<T>): Flu<T>

- Defined in flu.ts:10
Type parameters
- T
Parameters
- iter: () => AsyncIterable<T>
  - - (): AsyncIterable<T>
    - Returns AsyncIterable<T>
Returns Flu<T>

Properties

Readonly iter

iter: () => AsyncIterable<T>

Type declaration

- (): AsyncIterable<T>
- Returns AsyncIterable<T>

Generated using TypeDoc