baconjs (original) (raw)

Index

Type aliases

Accumulator

Accumulator<In, Out>: (acc: Out, value: In) => Out

Type parameters

Type declaration

- (acc: Out, value: In): Out
- Parameters
```
* ##### acc: Out  
* ##### value: In
```
Returns Out

Afters

AnyValue

ArrayTemplate

ArrayTemplate: Array

Type parameters

Binder

Type parameters

Type declaration

(sink: FlexibleSink<V>): Unsub

Parameters

* ##### sink: [FlexibleSink](globals.html#flexiblesink)<V\>

Returns Unsub

BoolTuple

BoolTuple: [T, boolean]

Type parameters

BufferHandler

BufferHandler: (buffer: Buffer<V>) => any

Type parameters

Type declaration

(buffer: Buffer<V>): any

Parameters

* ##### buffer: [Buffer](classes/buffer.html)<V\>

Returns any

Call

Call: () => any

Type declaration

- (): any
- Returns any

Combinator

Combinator<V, V2, R>: (x: V, y: V2) => R

Type parameters

Type declaration

- (x: V, y: V2): R
- Parameters
```
* ##### x: V  
* ##### y: V2
```
Returns R

CombinedTemplate

CombinedTemplate:

Type parameters

Ctx

Ctx: any

DecodedValueOf

Type parameters

DelayFunction

Type declaration

(f: VoidFunction): any

Parameters

* ##### f: [VoidFunction](globals.html#voidfunction)

Returns any

Differ

Type parameters

Equals

Equals: (left: A, right: A) => boolean

Type parameters

Type declaration

- (left: A, right: A): boolean
- Parameters
```
* ##### left: A  
* ##### right: A
```
Returns boolean

EventLike

Type parameters

EventOrValue

EventOrValue: Event<V> | V

Type parameters

EventSink

Type parameters

EventSourceFn

EventSourceFn: (binder: Function, listener: Function) => any

Type declaration

- (binder: Function, listener: Function): any
- Parameters
```
* ##### binder: Function  
* ##### listener: Function
```
Returns any

EventSpawner

EventSpawner<V, V2>: (e: Event<V>) => Observable<V2> | EventOrValue<V2>

Type parameters

Type declaration

- (e: Event<V>): Observable<V2> | EventOrValue<V2>
- Parameters
```
* ##### e: [Event](classes/event.html)<V\>
```
Returns Observable<V2> | EventOrValue<V2>

EventTransformer

EventTransformer: (...args: any[]) => EventLike<V>

Type parameters

Type declaration

- (...args: any[]): EventLike<V>
- Parameters
```
* ##### Rest ...args: any\[\]
```
Returns EventLike<V>

FlattenedObservable

FlattenedObservable: O extends Observable<infer I> ? I : O

Type parameters

FlexibleSink

Type parameters

Type declaration

(event: EventLike<V>): Reply

Parameters

* ##### event: [EventLike](globals.html#eventlike)<V\>

Returns Reply

Function0

Function0: () => R

Type parameters

Type declaration

- (): R
- Returns R

Function1

Function1<T1, R>: (t1: T1) => R

Type parameters

Type declaration

- (t1: T1): R
- Parameters
```
* ##### t1: T1
```
Returns R

Function2

Function2<T1, T2, R>: (t1: T1, t2: T2) => R

Type parameters

Type declaration

- (t1: T1, t2: T2): R
- Parameters
```
* ##### t1: T1  
* ##### t2: T2
```
Returns R

Function3

Function3<T1, T2, T3, R>: (t1: T1, t2: T2, t3: T3) => R

Type parameters

Type declaration

(t1: T1, t2: T2, t3: T3): R

Parameters

* ##### t1: T1  
* ##### t2: T2  
* ##### t3: T3

Returns R

Function4

Function4<T1, T2, T3, T4, R>: (t1: T1, t2: T2, t3: T3, t4: T4) => R

Type parameters

Type declaration

(t1: T1, t2: T2, t3: T3, t4: T4): R

Parameters

* ##### t1: T1  
* ##### t2: T2  
* ##### t3: T3  
* ##### t4: T4

Returns R

Function5

Function5<T1, T2, T3, T4, T5, R>: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R

Type parameters

Type declaration

(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R

Parameters

* ##### t1: T1  
* ##### t2: T2  
* ##### t3: T3  
* ##### t4: T4  
* ##### t5: T5

Returns R

Function6

Function6<T1, T2, T3, T4, T5, T6, R>: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6) => R

Type parameters

Type declaration

(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6): R

Parameters

* ##### t1: T1  
* ##### t2: T2  
* ##### t3: T3  
* ##### t4: T4  
* ##### t5: T5  
* ##### t6: T6

Returns R

GroupTransformer

GroupTransformer<V, V2>: (data: EventStream<V>, firstValue: V) => Observable<V2>

Type parameters

Type declaration

- (data: EventStream<V>, firstValue: V): Observable<V2>
- Parameters
```
* ##### data: [EventStream](classes/eventstream.html)<V\>  
* ##### firstValue: V
```
Returns Observable<V2>

ObjectTemplate

ObjectTemplate: {}

Type parameters

Type declaration

ObservableOrSource

ObservableOrSource: Observable<V> | Source<any, V>

Type parameters

ObservableWithParam

ObservableWithParam<T, P>: T extends Bus<any> | EventStream<any> ? EventStream<P> : T extends Property<any> ? Property<P> : Observable<P>

Type parameters

T: Observable<any>
P

Pattern

Type parameters

Pattern1

Type parameters

Pattern2

Type parameters

Pattern3

Type parameters

Pattern4

Pattern4<I1, I2, I3, I4, O>: [ObservableOrSource<I1>, ObservableOrSource<I1>, ObservableOrSource<I3>, ObservableOrSource<I4>, O | ((a: I1, b: I2, c: I3, d: I4) => O)]

Type parameters

Pattern5

Pattern5<I1, I2, I3, I4, I5, O>: [ObservableOrSource<I1>, ObservableOrSource<I1>, ObservableOrSource<I3>, ObservableOrSource<I4>, ObservableOrSource<I5>, O | ((a: I1, b: I2, c: I3, d: I4, e: I5) => O)]

Type parameters

Pattern6

Pattern6<I1, I2, I3, I4, I5, I6, O>: [ObservableOrSource<I1>, ObservableOrSource<I1>, ObservableOrSource<I3>, ObservableOrSource<I4>, ObservableOrSource<I5>, ObservableOrSource<I6>, O | ((a: I1, b: I2, c: I3, d: I4, e: I5, f: I6) => O)]

Type parameters

PollFunction

Type parameters

Type declaration

- (): EventLike<V>
- Returns EventLike<V>

Predicate

Type parameters

Predicate2Transformer

Type parameters

Type declaration

- (p: Predicate<V>): Transformer<V, V>
- Parameters
```
* ##### p: [Predicate](globals.html#predicate)<V\>
```
Returns Transformer<V, V>

PredicateOrProperty

Type parameters

Reply

Reply: "" | any

Sink

Sink<V, V>: (value: V) => any

Type parameters

Type declaration

- (value: V): any
- Parameters
```
* ##### value: V
```
Returns any

SpawnerOrObservable

SpawnerOrObservable<V, V2>: ValueSpawner<V, V2> | Observable<V2>

Type parameters

Spy

Spy: (obs: Observable<any>) => any

Type declaration

- (obs: Observable<any>): any
- Parameters
```
* ##### obs: Observable<any\>
```
Returns any

Type parameters

Type declaration

(arg: EventSink<T>): Unsub

Parameters

* ##### arg: [EventSink](globals.html#eventsink)<T\>

Returns Unsub

Transformer

Type parameters

Type declaration

(event: Event<V1>, sink: EventSink<V2>): Reply

Parameters

* ##### event: [Event](classes/event.html)<V1\>  
* ##### sink: [EventSink](globals.html#eventsink)<V2\>

Returns Reply

TypePredicate

TypePredicate<V, S>: (v: V) => v is S

Type parameters

V
S: V

Type declaration

- (v: V): v is S
- Parameters
```
* ##### v: V
```
Returns v is S

Unsub

Unsub: () => void

Type declaration

- (): void
- Returns void

UpdatePattern

Type parameters

UpdatePattern1

UpdatePattern1<I1, O>: [Observable<I1>, O | ((acc: O, a: I1) => O)]

Type parameters

UpdatePattern2

UpdatePattern2<I1, I2, O>: [Observable<I1>, Observable<I1>, O | ((acc: O, a: I1, b: I2) => O)]

Type parameters

UpdatePattern3

UpdatePattern3<I1, I2, I3, O>: [Observable<I1>, Observable<I1>, Observable<I3>, O | ((acc: O, a: I1, b: I2, c: I3) => O)]

Type parameters

UpdatePattern4

UpdatePattern4<I1, I2, I3, I4, O>: [Observable<I1>, Observable<I1>, Observable<I3>, Observable<I4>, O | ((acc: O, a: I1, b: I2, c: I3, d: I4) => O)]

Type parameters

UpdatePattern5

UpdatePattern5<I1, I2, I3, I4, I5, O>: [Observable<I1>, Observable<I1>, Observable<I3>, Observable<I4>, Observable<I5>, O | ((acc: O, a: I1, b: I2, c: I3, d: I4, e: I5) => O)]

Type parameters

UpdatePattern6

UpdatePattern6<I1, I2, I3, I4, I5, I6, O>: [Observable<I1>, Observable<I1>, Observable<I3>, Observable<I4>, Observable<I5>, Observable<I6>, O | ((acc: O, a: I1, b: I2, c: I3, d: I4, e: I5, f: I6) => O)]

Type parameters

ValueSpawner

ValueSpawner<V, V2>: (value: V) => V2 | Observable<V2> | Event<V2>

Type parameters

Type declaration

- (value: V): V2 | Observable<V2> | Event<V2>
- Parameters
```
* ##### value: V
```
Returns V2 | Observable<V2> | Event<V2>

VoidFunction

VoidFunction: () => void

Type declaration

- (): void
- Returns void

VoidSink

VoidSink: () => Reply

Type declaration

- (): Reply
- Returns Reply

Variables

Promise

Promise: any

aftersStack

aftersStack: [Afters[], number][] = []

aftersStackHeight

aftersStackHeight: number = 0

Const combine

flushed

flushed: {}

Type declaration

[key: number]: boolean

idCounter

idCounter: number = 0

Const makeFunction_

makeFunction_: (Anonymous function) = withMethodCallSupport(function(f: Function, ...args: any[]) {if (_.isFunction(f) ) {if (args.length) { return partiallyApplied(f, args); } else { return f; }} else {return _.always(f);}})

Const more

more: Reply = undefined

Const noMore

noMore: Reply = ""

Const nullMarker

nullMarker: {}

Type declaration

processingAfters

processingAfters: boolean = false

recursionDepth

recursionDepth: number = 0

rootEvent

rootEvent: Event<any> | undefined = undefined

running

running: boolean = false

spies

spies: Spy[] = []

Const version

version: "__version__" = "__version__"

waiterObs

waiters

waiters: {}

Type declaration

[obsId: number]: Call[]

Functions

afterTransaction

afterTransaction(obs: Observable, f: Call): void
Parameters
- obs: Observable
- f: Call

Returns void

cannotSync

cannotSync(source: AnySource): boolean
Parameters
- source: AnySource

Returns boolean

combineAsArray

combineAsArray(...streams: (Observable<V> | Observable<V>[])[]): Property<V[]>
Type parameters
- V

Parameters

Rest ...streams: (Observable<V> | Observable<V>[])[]

Returns Property<V[]>

combineTemplate

combineTemplate(template: T): Property<CombinedTemplate<T>>
Type parameters
- T

Parameters

template: T

Returns Property<CombinedTemplate<T>>

combineWith

combineWith(fn: Function0<R>): Property<R>
combineWith<V, R>(a: Observable<V>, fn: Function1<V, R>): Property<R>
combineWith<V, V2, R>(a: Observable<V>, b: Observable<V2>, fn: Function2<V, V2, R>): Property<R>
combineWith<V, V2, V3, R>(a: Observable<V>, b: Observable<V2>, c: Observable<V3>, fn: Function3<V, V2, V3, R>): Property<R>
combineWith<V, V2, V3, V4, R>(a: Observable<V>, b: Observable<V2>, c: Observable<V3>, d: Observable<V4>, fn: Function4<V, V2, V3, V4, R>): Property<R>
combineWith<V, V2, V3, V4, V5, R>(a: Observable<V>, b: Observable<V2>, c: Observable<V3>, d: Observable<V4>, e: Observable<V5>, fn: Function5<V, V2, V3, V4, V5, R>): Property<R>
combineWith<V, V2, V3, V4, V5, V6, R>(a: Observable<V>, b: Observable<V2>, c: Observable<V3>, d: Observable<V4>, e: Observable<V5>, f: Observable<V6>, fn: Function6<V, V2, V3, V4, V5, V6, R>): Property<R>
combineWith(observables: Observable<any>[], fn: Function): Property<R>
combineWith<V, R>(fn: Function1<V, R>, a: Observable<V>): Property<R>
combineWith<V, V2, R>(fn: Function2<V, V2, R>, a: Observable<V>, b: Observable<V2>): Property<R>
combineWith<V, V2, V3, R>(fn: Function3<V, V2, V3, R>, a: Observable<V>, b: Observable<V2>, c: Observable<V3>): Property<R>
combineWith<V, V2, V3, V4, R>(fn: Function4<V, V2, V3, V4, R>, a: Observable<V>, b: Observable<V2>, c: Observable<V3>, d: Observable<V4>): Property<R>
combineWith<V, V2, V3, V4, V5, R>(fn: Function5<V, V2, V3, V4, V5, R>, a: Observable<V>, b: Observable<V2>, c: Observable<V3>, d: Observable<V4>, e: Observable<V5>): Property<R>
combineWith<V, V2, V3, V4, V5, V6, R>(fn: Function6<V, V2, V3, V4, V5, V6, R>, a: Observable<V>, b: Observable<V2>, c: Observable<V3>, d: Observable<V4>, e: Observable<V5>, f: Observable<V6>): Property<R>
combineWith(fn: Function, observables: Observable<any>[]): Property<R>
Type parameters
- R

Parameters

fn: Function0<R>

Returns Property<R>

Type parameters
- V
- R

Parameters

a: Observable<V>
fn: Function1<V, R>

Returns Property<R>

Type parameters
- V
- V2
- R

Parameters

a: Observable<V>
b: Observable<V2>
fn: Function2<V, V2, R>

Returns Property<R>

Type parameters
- V
- V2
- V3
- R

Parameters

a: Observable<V>
b: Observable<V2>
c: Observable<V3>
fn: Function3<V, V2, V3, R>

Returns Property<R>

Type parameters
- V
- V2
- V3
- V4
- R

Parameters

a: Observable<V>
b: Observable<V2>
c: Observable<V3>
d: Observable<V4>
fn: Function4<V, V2, V3, V4, R>

Returns Property<R>

Type parameters
- V
- V2
- V3
- V4
- V5
- R

Parameters

a: Observable<V>
b: Observable<V2>
c: Observable<V3>
d: Observable<V4>
e: Observable<V5>
fn: Function5<V, V2, V3, V4, V5, R>

Returns Property<R>

Type parameters
- V
- V2
- V3
- V4
- V5
- V6
- R

Parameters

a: Observable<V>
b: Observable<V2>
c: Observable<V3>
d: Observable<V4>
e: Observable<V5>
f: Observable<V6>
fn: Function6<V, V2, V3, V4, V5, V6, R>

Returns Property<R>

Type parameters
- R

Parameters

observables: Observable<any>[]
fn: Function

Returns Property<R>

Type parameters
- V
- R

Parameters

fn: Function1<V, R>
a: Observable<V>

Returns Property<R>

Type parameters
- V
- V2
- R

Parameters

fn: Function2<V, V2, R>
a: Observable<V>
b: Observable<V2>

Returns Property<R>

Type parameters
- V
- V2
- V3
- R

Parameters

fn: Function3<V, V2, V3, R>
a: Observable<V>
b: Observable<V2>
c: Observable<V3>

Returns Property<R>

Type parameters
- V
- V2
- V3
- V4
- R

Parameters

fn: Function4<V, V2, V3, V4, R>
a: Observable<V>
b: Observable<V2>
c: Observable<V3>
d: Observable<V4>

Returns Property<R>

Type parameters
- V
- V2
- V3
- V4
- V5
- R

Parameters

fn: Function5<V, V2, V3, V4, V5, R>
a: Observable<V>
b: Observable<V2>
c: Observable<V3>
d: Observable<V4>
e: Observable<V5>

Returns Property<R>

Type parameters
- V
- V2
- V3
- V4
- V5
- V6
- R

Parameters

fn: Function6<V, V2, V3, V4, V5, V6, R>
a: Observable<V>
b: Observable<V2>
c: Observable<V3>
d: Observable<V4>
e: Observable<V5>
f: Observable<V6>

Returns Property<R>

Type parameters
- R

Parameters

fn: Function
observables: Observable<any>[]

Returns Property<R>

concatAll

concatAll(...streams_: (Observable<V> | Observable<V>[])[]): EventStream<V>
Type parameters
- V

Parameters

Rest ...streams_: (Observable<V> | Observable<V>[])[]

Returns EventStream<V>

constant

constant(x: V): Property<V>
Type parameters
- V

Parameters

x: V

Returns Property<V>

containsDuplicateDeps

containsDuplicateDeps(observables: AnyObservable[], state?: AnyObservable[]): boolean
Parameters
- observables: AnyObservable[]
- Default value state: AnyObservable[] = []

Returns boolean

containsObs

containsObs(obs: Observable, aftersList: Afters[]): boolean
Parameters
- obs: Observable
- aftersList: Afters[]

Returns boolean

currentEventId

currentEventId(): undefined | number
Returns undefined | number

ensureStackHeight

ensureStackHeight(h: number): void
Parameters
- h: number

Returns void

extractLegacyPatterns

extractLegacyPatterns(sourceArgs: any[]): RawPattern[]
Parameters
- sourceArgs: any[]

Returns RawPattern[]

findHandlerMethods

findHandlerMethods(target: any): [Function, Function]
Parameters
- target: any

Returns [Function, Function]

flush

flush(): void
Returns void

flushDepsOf

flushDepsOf(obs: Observable): void
Parameters
- obs: Observable

Returns void

flushWaiters

flushWaiters(index: number, deps: boolean): void
Parameters
- index: number
- deps: boolean

Returns void

fromArray

fromArray(values: (T | Event<T>)[]): EventStream<T>
Type parameters
- T

Parameters

values: (T | Event<T>)[]

Returns EventStream<T>

fromBinder

fromBinder(binder: Binder<V>, eventTransformer?: EventTransformer<V>): EventStream<V>
Type parameters
- V

Parameters

binder: Binder<V>
Default value eventTransformer: EventTransformer<V> = _.id

Returns EventStream<V>

fromCallback

fromCallback(f: Function, ...args: any[]): EventStream<V>
Type parameters
- V

Parameters

f: Function
Rest ...args: any[]

Returns EventStream<V>

fromESObservable

fromESObservable(_observable: any): EventStream<V>
Type parameters
- V

Parameters

_observable: any

Returns EventStream<V>

fromEvent

fromEvent(target: any, eventSource: string | EventSourceFn, eventTransformer?: EventTransformer<V>): EventStream<V>
Type parameters
- V

Parameters

target: any
eventSource: string | EventSourceFn
Optional eventTransformer: EventTransformer<V>

Returns EventStream<V>

fromNodeCallback

fromNodeCallback(f: Function, ...args: any[]): EventStream<V>
Type parameters
- V

Parameters

f: Function
Rest ...args: any[]

Returns EventStream<V>

fromPoll

fromPoll(delay: number, poll: PollFunction<V>): EventStream<V>
Type parameters
- V

Parameters

delay: number
poll: PollFunction<V>

Returns EventStream<V>

fromPromise

fromPromise(promise: Promise<V>, abort?: undefined | false | true, eventTransformer?: EventTransformer<V>): EventStream<V>
Type parameters
- V

Parameters

promise: Promise<V>
Optional abort: undefined | false | true
Default value eventTransformer: EventTransformer<V> = valueAndEnd

Returns EventStream<V>

getScheduler

getScheduler(): Scheduler
Returns Scheduler

hasValue

hasValue(e: Event<V>): e is Value<V>
Type parameters
- V

Parameters

e: Event<V>

Returns e is Value<V>

hasWaiters

hasWaiters(): boolean
Returns boolean

inTransaction

inTransaction(event: Event<any> | undefined, context: any, f: Function, args: any[]): any
Parameters
- event: Event<any> | undefined
- context: any
- f: Function
- args: any[]

Returns any

interval

interval(delay: number, value: V): EventStream<V>
Type parameters
- V

Parameters

delay: number
value: V

Returns EventStream<V>

isEnd

isEnd(e: Event<V>): e is End
Type parameters
- V

Parameters

e: Event<V>

Returns e is End

isError

isError(e: Event<V>): e is Error
Type parameters
- V

Parameters

e: Event<V>

Returns e is Error

isEvent

isEvent(e: any): e is Event<V>
Type parameters
- V

Parameters

e: any

Returns e is Event<V>

isEventSourceFn

isEventSourceFn(x: any): x is EventSourceFn
Parameters
- x: any

Returns x is EventSourceFn

isInTransaction

isInTransaction(): boolean
Returns boolean

isInitial

isInitial(e: Event<V>): e is Initial<V>
Type parameters
- V

Parameters

e: Event<V>

Returns e is Initial<V>

isNext

isNext(e: Event<V>): e is Next<V>
Type parameters
- V

Parameters

e: Event<V>

Returns e is Next<V>

isNone

isNone(object: any): boolean
Parameters
- object: any

Returns boolean

isRawPattern

isRawPattern(pattern: Pattern<any>): pattern is RawPattern
Parameters
- pattern: Pattern<any>

Returns pattern is RawPattern

isTypedOrRawPattern

isTypedOrRawPattern(pattern: Pattern<any>): boolean
Parameters
- pattern: Pattern<any>

Returns boolean

lateBindFirst

lateBindFirst(f: Function): (Anonymous function)
Parameters
- f: Function

Returns (Anonymous function)

later

later(delay: number, value: V): EventStream<V>
Type parameters
- V

Parameters

delay: number
value: V

Returns EventStream<V>

makeCombinator

makeCombinator<V, V2, R>(combinator: Combinator<V, V2, R> | undefined): Combinator<V, V2, R>
Type parameters
- V
- V2
- R

Parameters

combinator: Combinator<V, V2, R> | undefined

Returns Combinator<V, V2, R>

mergeAll

mergeAll(...streams: (Observable<V> | Observable<V>[])[]): EventStream<V>
Type parameters
- V

Parameters

Rest ...streams: (Observable<V> | Observable<V>[])[]

Returns EventStream<V>

never

never(): EventStream<V>
Type parameters
- V

Returns EventStream<V>

none

none(): Option<T>
Type parameters
- T

Returns Option<T>

onValues

onValues(...args: any[]): Unsub
Parameters
- Rest ...args: any[]

Returns Unsub

once

once(value: V | Event<V>): EventStream<V>
Type parameters
- V

Parameters

value: V | Event<V>

Returns EventStream<V>

partiallyApplied

partiallyApplied(f: Function, applied: any[]): (Anonymous function)
Parameters
- f: Function
- applied: any[]

Returns (Anonymous function)

processAfters

processAfters(): void
Returns void

processRawPatterns

processRawPatterns(rawPatterns: RawPattern[]): [AnySource[], IndexPattern[]]
Parameters
- rawPatterns: RawPattern[]

Returns [AnySource[], IndexPattern[]]

repeat

repeat(generator: (iteration: number) => undefined | Observable<V>): EventStream<V>
Type parameters
- V

Parameters

generator: (iteration: number) => undefined | Observable<V>

* * (iteration: number): undefined | Observable<V\>  
         * #### Parameters  
                     * ##### iteration: number  
         #### Returns undefined | Observable<V\>

Returns EventStream<V>

repeatedly

repeatedly(delay: number, values: (V | Event<V>)[]): EventStream<V>
Type parameters
- V

Parameters

delay: number
values: (V | Event<V>)[]

Returns EventStream<V>

retry

retry(options: RetryOptions<V>): EventStream<V>
Type parameters
- V

Parameters

options: RetryOptions<V>

Returns EventStream<V>

sequentially

sequentially(delay: number, values: (V | Event<V>)[]): EventStream<V>
Type parameters
- V

Parameters

delay: number
values: (V | Event<V>)[]

Returns EventStream<V>

setScheduler

setScheduler(newScheduler: Scheduler): void
Parameters
- newScheduler: Scheduler

Returns void

silence

silence(duration: number): EventStream<V>
Type parameters
- V

Parameters

duration: number

Returns EventStream<V>

singleToObservables

singleToObservables(x: T | Observable<T> | Observable<T>[]): Observable<T>[]
Type parameters
- T

Parameters

x: T | Observable<T> | Observable<T>[]

Returns Observable<T>[]

soonButNotYet

soonButNotYet(obs: Observable, f: Call): void
Parameters
- obs: Observable
- f: Call

Returns void

Const spy

spy(spy: Spy): number
Parameters
- spy: Spy

Returns number

symbol

symbol(key: string): any
Parameters
- key: string

Returns any

takeWhileT

takeWhileT(f: Predicate<V>): Transformer<V, V>
Type parameters
- V

Parameters

f: Predicate<V>

Returns Transformer<V, V>

toDelayFunction

toDelayFunction(delay: number | DelayFunction | undefined): DelayFunction | undefined
Parameters
- delay: number | DelayFunction | undefined

Returns DelayFunction | undefined

toOption

toOption(v: V | Option<V>): Option<V>
Type parameters
- V

Parameters

v: V | Option<V>

Returns Option<V>

toProperty

toProperty(x: V | Property<V>): (V & Property<unknown>) | (Property<V> & Property<unknown>) | Property<V | Property<V>>
Type parameters
- V

Parameters

x: V | Property<V>

Returns (V & Property<unknown>) | (Property<V> & Property<unknown>) | Property<V | Property<V>>

tryF

tryF<In, Out>(f: (value: In) => Out): (value: In) => EventStream<Out>
Type parameters
- In
- Out

Parameters

f: (value: In) => Out

* * (value: In): Out  
         * #### Parameters  
                     * ##### value: In  
         #### Returns Out

Returns (value: In) => EventStream<Out>

- (value: In): EventStream<Out>
  - Parameters
```
   * ##### value: In
```
  Returns EventStream<Out>

update

update(initial: Out, ...patterns: UpdatePattern<Out>[]): Property<Out>
Type parameters
- Out

Parameters

initial: Out
Rest ...patterns: UpdatePattern<Out>[]

Returns Property<Out>

valueAndEnd

valueAndEnd(value: V): EventLike<V>
Type parameters
- V

Parameters

value: V

Returns EventLike<V>

when

when(...patterns: Pattern<O>[]): EventStream<O>
Type parameters
- O

Parameters

Rest ...patterns: Pattern<O>[]

Returns EventStream<O>

whenDoneWith

whenDoneWith(obs: Observable, f: Call): any
Parameters
- obs: Observable
- f: Call

Returns any

withMethodCallSupport

withMethodCallSupport(wrapped: Function): (Anonymous function)
Parameters
- wrapped: Function

Returns (Anonymous function)

withStateMachineT

withStateMachineT<In, State, Out>(initState: State, f: StateF<In, State, Out>): Transformer<In, Out>
Type parameters
- In
- State
- Out

Parameters

initState: State
f: StateF<In, State, Out>

Returns Transformer<In, Out>

wrap

wrap(obs: Observable<V>): DefaultSource<V>
Type parameters
- V

Parameters

obs: Observable<V>

Returns DefaultSource<V>

wrappedSubscribe

wrappedSubscribe(obs: Observable, subscribe: Subscribe<V>, sink: EventSink<V>): unsub
Type parameters
- V

Parameters

obs: Observable
subscribe: Subscribe<V>
sink: EventSink<V>

Returns unsub

zipAsArray

zipAsArray(...args: (Observable<V> | Observable<V>[])[]): Observable<V[]>
Type parameters
- V

Parameters

Rest ...args: (Observable<V> | Observable<V>[])[]

Returns Observable<V[]>

zipWith

zipWith(f: (...any: any[]) => Out, ...streams: Observable<any>[]): EventStream<Out>
Type parameters
- Out

Parameters

f: (...any: any[]) => Out

* * (...any: any\[\]): Out  
         * #### Parameters  
                     * ##### Rest ...any: any\[\]  
         #### Returns Out

Rest ...streams: Observable<any>[]

Returns EventStream<Out>

Object literals

Const $

$: object

asEventStream

asEventStream(eventName: string, selector: string | undefined, eventTransformer: any): EventStream<any>
Parameters
- eventName: string
- selector: string | undefined
- eventTransformer: any

Returns EventStream<any>

init

init(jQuery: any): void
Parameters
- jQuery: any

Returns void

Const GlobalScheduler

GlobalScheduler: object

scheduler

scheduler: Scheduler = defaultScheduler

_

_: object

all

all: all

always

always: always

any

any: any

bind

bind: bind

contains

contains: contains

each

each: each

empty

empty: empty

filter

filter: filter

flatMap

flatMap: flatMap

fold

fold: fold

head

head: head

id

id: id

indexOf

indexOf: indexOfDefault

indexWhere

indexWhere: indexWhere

isFunction

isFunction: isFunction

last

last: last

map

map: map

negate

negate: negate

remove

remove: remove

tail

tail: tail

toArray

toArray: toArray

toFunction

toFunction: toFunction

toString

toString: toString

without

without: without