Event | ts-primitives

To an event a function with one or zero parameters can be subscribed. The event is the subscriber function itself.

Type parameters

Callable

__call(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore): IDisposable

- Defined in dist/index.d.ts:121
To an event a function with one or zero parameters can be subscribed. The event is the subscriber function itself.

Parameters
- listener: (e: T) => any
  - - (e: T): any
    - Parameters
      - e: T
      Returns any
- Optional thisArgs: any
- Optional disposables: IDisposable[] | DisposableStore
Returns IDisposable

Index

Interfaces

Variables

None

Functions

Variables

Const None

None: Event<any>

Functions

any

any<T>(...events: Event<T>[]): Event<T>
any(...events: Event<any>[]): Event<void>

- Defined in dist/index.d.ts:154
Given a collection of events, returns a single event which emits whenever any of the provided events emit.

Type parameters
- T
Parameters
- Rest ...events: Event<T>[]
Returns Event<T>
- Defined in dist/index.d.ts:155
Parameters
- Rest ...events: Event<any>[]
Returns Event<void>

buffer

buffer<T>(event: Event<T>, nextTick?: boolean, _buffer?: T[]): Event<T>

- Defined in dist/index.d.ts:211
Buffers the provided event until a first listener comes along, at which point fire all the events at once and pipe the event from then on.
```
const emitter = new Emitter<number>();
const event = emitter.event;
const bufferedEvent = buffer(event);

emitter.fire(1);
emitter.fire(2);
emitter.fire(3);
// nothing...

const listener = bufferedEvent(num => console.log(num));
// 1, 2, 3

emitter.fire(4);
// 4
```
Type parameters
- T
Parameters
- event: Event<T>
- Optional nextTick: boolean
- Optional _buffer: T[]
Returns Event<T>

chain

chain<T>(event: Event<T>): IChainableEvent<T>

- Defined in dist/index.d.ts:225
Type parameters
- T
Parameters
- event: Event<T>
Returns IChainableEvent<T>

debounce

debounce<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, leakWarningThreshold?: number): Event<T>
debounce<I, O>(event: Event, merge: (last: O | undefined, event: I) => O, delay?: number, leading?: boolean, leakWarningThreshold?: number): Event<O>

- Defined in dist/index.d.ts:176
Debounces the provided event, given a merge function.

Type parameters
- T
Parameters
- event: Event<T>
 
 The input event.
- merge: (last: T | undefined, event: T) => T
 
 The reducing function.
 - - (last: T | undefined, event: T): T
 - Parameters
 - last: T | undefined
 - event: T
 Returns T
- Optional delay: number
 
 The debouncing delay in millis.
- Optional leading: boolean
 
 Whether the event should fire in the leading phase of the timeout.
- Optional leakWarningThreshold: number
 
 The leak warning threshold override.
Returns Event<T>
- Defined in dist/index.d.ts:177
Type parameters
- I
- O
Parameters
- event: Event
- merge: (last: O | undefined, event: I) => O
 - - (last: O | undefined, event: I): O
 - Parameters
 - last: O | undefined
 - event: I
 Returns O
- Optional delay: number
- Optional leading: boolean
- Optional leakWarningThreshold: number
Returns Event<O>

filter

filter<T>(event: Event<T>, filter: (e: T) => boolean): Event<T>
filter<T, R>(event: Event<T | R>, filter: (e: T | R) => e is R): Event<R>

- Defined in dist/index.d.ts:144
Given an event and a filter function, returns another event which emits those elements for which the filter function returns true.

Type parameters
- T
Parameters
- event: Event<T>
- filter: (e: T) => boolean
 - - (e: T): boolean
 - Parameters
 - e: T
 Returns boolean
Returns Event<T>
- Defined in dist/index.d.ts:145
Type parameters
- T
- R
Parameters
- event: Event<T | R>
- filter: (e: T | R) => e is R
 - - (e: T | R): e is R
 - Parameters
 - e: T | R
 Returns e is R
Returns Event<R>

forEach

forEach(event: Event, each: (i: I) => void): Event

- Defined in dist/index.d.ts:139
Given an event and an each function, returns another identical event and calls the each function per each element.

Type parameters
- I
Parameters
- event: Event
- each: (i: I) => void
 - - (i: I): void
 - Parameters
 - i: I
 Returns void
Returns Event

fromDOMEventEmitter

fromDOMEventEmitter<T>(emitter: DOMEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>

- Defined in dist/index.d.ts:235
Type parameters
- T
Parameters
- emitter: DOMEventEmitter
- eventName: string
- Optional map: (...args: any[]) => T
 - - (...args: any[]): T
 - Parameters
 - Rest ...args: any[]
 Returns T
Returns Event<T>

fromNodeEventEmitter

fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>

- Defined in dist/index.d.ts:230
Type parameters
- T
Parameters
- emitter: NodeEventEmitter
- eventName: string
- Optional map: (...args: any[]) => T
 - - (...args: any[]): T
 - Parameters
 - Rest ...args: any[]
 Returns T
Returns Event<T>

fromPromise

fromPromise<T>(promise: Promise<T>): Event<undefined>

- Defined in dist/index.d.ts:236
Type parameters
- T
Parameters
- promise: Promise<T>
Returns Event<undefined>

latch

latch<T>(event: Event<T>): Event<T>

- Defined in dist/index.d.ts:188
Given an event, it returns another event which fires only when the event element changes.

Type parameters
- T
Parameters
- event: Event<T>
Returns Event<T>

map

map<I, O>(event: Event, map: (i: I) => O): Event<O>

- Defined in dist/index.d.ts:134
Given an event and a map function, returns another event which maps each element through the mapping function.

Type parameters
- I
- O
Parameters
- event: Event
- map: (i: I) => O
 - - (i: I): O
 - Parameters
 - i: I
 Returns O
Returns Event<O>

once

once<T>(event: Event<T>): Event<T>

- Defined in dist/index.d.ts:129
Given an event, returns another event which only fires once.

Type parameters
- T
Parameters
- event: Event<T>
Returns Event<T>

reduce

reduce<I, O>(event: Event, merge: (last: O | undefined, event: I) => O, initial?: O): Event<O>

- Defined in dist/index.d.ts:160
Given an event and a merge function, returns another event which maps each element and the cumulative result through the merge function. Similar to map, but with memory.

Type parameters
- I
- O
Parameters
- event: Event
- merge: (last: O | undefined, event: I) => O
 - - (last: O | undefined, event: I): O
 - Parameters
 - last: O | undefined
 - event: I
 Returns O
- Optional initial: O
Returns Event<O>

signal

signal<T>(event: Event<T>): Event<void>

- Defined in dist/index.d.ts:149
Given an event, returns the same event but typed as Event<void>.

Type parameters
- T
Parameters
- event: Event<T>
Returns Event<void>

snapshot

snapshot<T>(event: Event<T>): Event<T>

- Defined in dist/index.d.ts:166
Given a chain of event processing functions (filter, map, etc), each function will be invoked per event & per listener. Snapshotting an event chain allows each function to be invoked just once per event.

Type parameters
- T
Parameters
- event: Event<T>
Returns Event<T>

stopwatch

stopwatch<T>(event: Event<T>): Event<number>

- Defined in dist/index.d.ts:183
Given an event, it returns another event which fires only once and as soon as the input event emits. The event data is the number of millis it took for the event to fire.

Type parameters
- T
Parameters
- event: Event<T>
Returns Event<number>

toPromise

toPromise<T>(event: Event<T>): Promise<T>

- Defined in dist/index.d.ts:237
Type parameters
- T
Parameters
- event: Event<T>
Returns Promise<T>

Type parameters

T

Callable

Parameters

listener: (e: T) => any

Parameters

e: T

Returns any

Optional thisArgs: any

Optional disposables: IDisposable[] | DisposableStore

Returns IDisposable

Index

Interfaces

Variables

Functions

Variables

Const None

Functions

any

Type parameters

T

Parameters

Rest ...events: Event<T>[]

Returns Event<T>

Parameters

Rest ...events: Event<any>[]

Returns Event<void>

buffer

Type parameters

T

Parameters

event: Event<T>

Optional nextTick: boolean

Optional _buffer: T[]

Returns Event<T>

chain

Type parameters

T

Parameters

event: Event<T>

Returns IChainableEvent<T>

debounce

Type parameters

T

Parameters

event: Event<T>

merge: (last: T | undefined, event: T) => T

Parameters

last: T | undefined

event: T

Returns T

Optional delay: number

Optional leading: boolean

Optional leakWarningThreshold: number

Returns Event<T>

Type parameters

I

O

Parameters

event: Event<I>

merge: (last: O | undefined, event: I) => O

Parameters

last: O | undefined

event: I

Returns O

Optional delay: number

Optional leading: boolean

Optional leakWarningThreshold: number

Returns Event<O>

filter

Type parameters

T

Parameters

event: Event<T>

filter: (e: T) => boolean

Parameters

e: T

Returns boolean

Returns Event<T>

Type parameters