mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2026-10-04 06:47:03 +00:00
Merge pull request #31913 from mAAdhaTTah/fix-kefir-types
Improve Kefir types
This commit is contained in:
Ron Buckton
Vendored
+170
-165
@@ -1,9 +1,9 @@
|
||||
// Type definitions for Kefir 3.7.3
|
||||
// Type definitions for Kefir 3.8.0
|
||||
// Project: http://rpominov.github.io/kefir/
|
||||
// Definitions by: Aya Morisawa <https://github.com/AyaMorisawa>
|
||||
// Piotr Hitori Bosak <https://github.com/HitoriSensei>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
// TypeScript Version: 2.4
|
||||
// TypeScript Version: 2.7
|
||||
|
||||
/// <reference types="node" />
|
||||
|
||||
@@ -11,7 +11,7 @@ export type ValueOfAnObservable<T extends Observable<any, any>> = T[''];
|
||||
|
||||
export interface Subscription {
|
||||
unsubscribe(): void;
|
||||
closed: boolean; // Actually, `readonly` but it's avaiable in tsc starting with 2.0.0
|
||||
readonly closed: boolean;
|
||||
}
|
||||
|
||||
export interface Observer<T, S> {
|
||||
@@ -20,21 +20,24 @@ export interface Observer<T, S> {
|
||||
end?: () => void;
|
||||
}
|
||||
|
||||
export interface Subscription {
|
||||
unsubscribe(): void;
|
||||
closed: boolean; // Actually, `readonly` but it's avaiable in tsc starting with 2.0.0
|
||||
interface ESObserver<T, S> {
|
||||
start?: Function,
|
||||
next?: (value: T) => any,
|
||||
error?: (error: S) => any,
|
||||
complete?: () => any,
|
||||
}
|
||||
|
||||
export interface Observer<T, S> {
|
||||
value?: (value: T) => void;
|
||||
error?: (error: S) => void;
|
||||
end?: () => void;
|
||||
interface ESObservable<T, S> {
|
||||
subscribe(callbacks: ESObserver<T, S>): { unsubscribe(): void };
|
||||
}
|
||||
|
||||
export interface Observable<T, S> {
|
||||
export class Observable<T, S> {
|
||||
'': T; // TypeScript hack to enable value unwrapping for combine/flatMap
|
||||
|
||||
toProperty(getCurrent?: () => T): Property<T, S>;
|
||||
toProperty(): Property<T, S>;
|
||||
toProperty<T2>(getCurrent?: () => T2): Property<T | T2, S>;
|
||||
changes(): Observable<T, S>;
|
||||
|
||||
// Subscribe / add side effects
|
||||
onValue(callback: (value: T) => void): this;
|
||||
offValue(callback: (value: T) => void): this;
|
||||
@@ -42,8 +45,8 @@ export interface Observable<T, S> {
|
||||
offError(callback: (error: S) => void): this;
|
||||
onEnd(callback: () => void): this;
|
||||
offEnd(callback: () => void): this;
|
||||
onAny(callback: (event: Event<T | S>) => void): this;
|
||||
offAny(callback: (event: Event<T | S>) => void): this;
|
||||
onAny(callback: (event: Event<T, S>) => void): this;
|
||||
offAny(callback: (event: Event<T, S>) => void): this;
|
||||
log(name?: string): this;
|
||||
spy(name?: string): this;
|
||||
offLog(name?: string): this;
|
||||
@@ -51,7 +54,7 @@ export interface Observable<T, S> {
|
||||
flatten<U>(transformer?: (value: T) => U[]): Stream<U, S>;
|
||||
toPromise(): Promise<T>;
|
||||
toPromise<W extends PromiseLike<T>>(PromiseConstructor: () => W): W;
|
||||
toESObservable(): any;
|
||||
toESObservable(): ESObservable<T, S>;
|
||||
// This method is designed to replace all other methods for subscribing
|
||||
observe(params: Observer<T, S>): Subscription;
|
||||
observe(
|
||||
@@ -61,172 +64,174 @@ export interface Observable<T, S> {
|
||||
): Subscription;
|
||||
setName(source: Observable<any, any>, selfName: string): this;
|
||||
setName(selfName: string): this;
|
||||
}
|
||||
|
||||
export interface Stream<T, S> extends Observable<T, S> {
|
||||
thru<R>(cb: (obs: Observable<T, S>) => Observable<R, S>): Observable<R, S>;
|
||||
// Modify an stream
|
||||
map<U>(fn: (value: T) => U): Stream<U, S>;
|
||||
filter(predicate?: (value: T) => boolean): Stream<T, S>;
|
||||
take(n: number): Stream<T, S>;
|
||||
takeWhile(predicate?: (value: T) => boolean): Stream<T, S>;
|
||||
last(): Stream<T, S>;
|
||||
skip(n: number): Stream<T, S>;
|
||||
skipWhile(predicate?: (value: T) => boolean): Stream<T, S>;
|
||||
skipDuplicates(comparator?: (a: T, b: T) => boolean): Stream<T, S>;
|
||||
diff(fn?: (prev: T, next: T) => T, seed?: T): Stream<T, S>;
|
||||
scan<W>(fn: (prev: T | W, next: T) => W): Stream<W, S>;
|
||||
scan<W>(fn: (prev: W, next: T) => W, seed: W): Stream<W, S>;
|
||||
delay(wait: number): Stream<T, S>;
|
||||
throttle(wait: number, options?: { leading?: boolean, trailing?: boolean }): Stream<T, S>;
|
||||
debounce(wait: number, options?: { immediate: boolean }): Stream<T, S>;
|
||||
valuesToErrors(): Stream<never, S | T>;
|
||||
valuesToErrors<U>(handler: (value: T) => { convert: boolean, error: U }): Stream<never, S | U>;
|
||||
errorsToValues<U>(handler?: (error: S) => { convert: boolean, value: U }): Stream<T | U, never>;
|
||||
mapErrors<U>(fn: (error: S) => U): Stream<T, U>;
|
||||
filterErrors(predicate?: (error: S) => boolean): Stream<T, S>;
|
||||
endOnError(): Stream<T, S>;
|
||||
takeErrors(n: number): Stream<T, S>;
|
||||
ignoreValues(): Stream<never, S>;
|
||||
ignoreErrors(): Stream<T, never>;
|
||||
ignoreEnd(): Stream<T, S>;
|
||||
beforeEnd<U>(fn: () => U): Stream<T | U, S>;
|
||||
slidingWindow(max: number, mix?: number): Stream<T[], S>;
|
||||
bufferWhile(predicate: (value: T) => boolean): Stream<T[], S>;
|
||||
bufferWithCount(count: number, options?: { flushOnEnd: boolean }): Stream<T[], S>;
|
||||
bufferWithTimeOrCount(interval: number, count: number, options?: { flushOnEnd: boolean }): Stream<T[], S>;
|
||||
transduce<U>(transducer: any): Stream<U, S>;
|
||||
withHandler<U, V>(handler: (emitter: Emitter<U, S>, event: Event<T | S>) => void): Stream<U, S>;
|
||||
map<U>(fn: (value: T) => U): Observable<U, S>;
|
||||
filter<U extends T>(fn: (value: T) => value is U): Observable<U, S>
|
||||
filter(predicate?: (value: T) => boolean): Observable<T, S>;
|
||||
take(n: number): Observable<T, S>;
|
||||
takeWhile(predicate?: (value: T) => boolean): Observable<T, S>;
|
||||
last(): Observable<T, S>;
|
||||
skip(n: number): Observable<T, S>;
|
||||
skipWhile(predicate?: (value: T) => boolean): Observable<T, S>;
|
||||
skipDuplicates(comparator?: (a: T, b: T) => boolean): Observable<T, S>;
|
||||
diff(fn?: (prev: T, next: T) => T, seed?: T): Observable<T, S>;
|
||||
scan<W>(fn: (prev: T | W, next: T) => W): Observable<W, S>;
|
||||
scan<W>(fn: (prev: W, next: T) => W, seed: W): Observable<W, S>;
|
||||
delay(wait: number): Observable<T, S>;
|
||||
throttle(wait: number, options?: { leading?: boolean, trailing?: boolean }): Observable<T, S>;
|
||||
debounce(wait: number, options?: { immediate: boolean }): Observable<T, S>;
|
||||
valuesToErrors(): Observable<never, S | T>;
|
||||
valuesToErrors<U>(handler: (value: T) => { convert: boolean, error: U }): Observable<never, S | U>;
|
||||
errorsToValues<U>(handler?: (error: S) => { convert: boolean, value: U }): Observable<T | U, never>;
|
||||
mapErrors<U>(fn: (error: S) => U): Observable<T, U>;
|
||||
filterErrors(predicate?: (error: S) => boolean): Observable<T, S>;
|
||||
endOnError(): Observable<T, S>;
|
||||
takeErrors(n: number): Observable<T, S>;
|
||||
ignoreValues(): Observable<never, S>;
|
||||
ignoreErrors(): Observable<T, never>;
|
||||
ignoreEnd(): Observable<T, S>;
|
||||
beforeEnd<U>(fn: () => U): Observable<T | U, S>;
|
||||
slidingWindow(max: number, mix?: number): Observable<T[], S>;
|
||||
bufferWhile(predicate: (value: T) => boolean): Observable<T[], S>;
|
||||
bufferWithCount(count: number, options?: { flushOnEnd: boolean }): Observable<T[], S>;
|
||||
bufferWithTimeOrCount(interval: number, count: number, options?: { flushOnEnd: boolean }): Observable<T[], S>;
|
||||
transduce<U>(transducer: any): Observable<U, S>;
|
||||
withHandler<U, V>(handler: (emitter: Emitter<U, S>, event: Event<T, S>) => void): Observable<U, S>;
|
||||
// Combine streams
|
||||
combine<U, V, W>(otherObs: Stream<U, V>, combinator?: (value: T, ...values: U[]) => W): Stream<W, S | V>;
|
||||
zip<U, V, W>(otherObs: Stream<U, V>, combinator?: (value: T, ...values: U[]) => W): Stream<W, S | V>;
|
||||
merge<U, V>(otherObs: Stream<U, V>): Stream<T | U, S | V>;
|
||||
concat<U, V>(otherObs: Stream<U, V>): Stream<T | U, S | V>;
|
||||
flatMap<U, V>(transform: (value: T) => Stream<U, V>): Stream<U, V>;
|
||||
flatMap<X extends T & Property<T, any>>(): Stream<ValueOfAnObservable<X>, any>;
|
||||
flatMapLatest<U, V>(fn: (value: T) => Stream<U, V>): Stream<U, V>;
|
||||
flatMapLatest<X extends T & Property<T, any>>(): Stream<ValueOfAnObservable<X>, any>;
|
||||
flatMapFirst<U, V>(fn: (value: T) => Stream<U, V>): Stream<U, V>;
|
||||
flatMapFirst<X extends T & Property<T, any>>(): Stream<ValueOfAnObservable<X>, any>;
|
||||
flatMapConcat<U, V>(fn: (value: T) => Stream<U, V>): Stream<U, V>;
|
||||
flatMapConcat<X extends T & Property<T, any>>(): Stream<ValueOfAnObservable<X>, any>;
|
||||
flatMapConcurLimit<U, V>(fn: (value: T) => Stream<U, V>, limit: number): Stream<U, V>;
|
||||
flatMapErrors<U, V>(transform: (error: S) => Stream<U, V>): Stream<U, V>;
|
||||
combine<U, V, W>(otherObs: Observable<U, V>, combinator?: (value: T, ...values: U[]) => W): Observable<W, S | V>;
|
||||
zip<U, V, W>(otherObs: Observable<U, V>, combinator?: (value: T, ...values: U[]) => W): Observable<W, S | V>;
|
||||
merge<U, V>(otherObs: Observable<U, V>): Observable<T | U, S | V>;
|
||||
concat<U, V>(otherObs: Observable<U, V>): Observable<T | U, S | V>;
|
||||
flatMap<U, V>(transform: (value: T) => Observable<U, V>): Observable<U, V>;
|
||||
flatMap<X extends T & Property<T, any>>(): Observable<ValueOfAnObservable<X>, any>;
|
||||
flatMapLatest<U, V>(fn: (value: T) => Observable<U, V>): Observable<U, V>;
|
||||
flatMapLatest<X extends T & Property<T, any>>(): Observable<ValueOfAnObservable<X>, any>;
|
||||
flatMapFirst<U, V>(fn: (value: T) => Observable<U, V>): Observable<U, V>;
|
||||
flatMapFirst<X extends T & Property<T, any>>(): Observable<ValueOfAnObservable<X>, any>;
|
||||
flatMapConcat<U, V>(fn: (value: T) => Observable<U, V>): Observable<U, V>;
|
||||
flatMapConcat<X extends T & Property<T, any>>(): Observable<ValueOfAnObservable<X>, any>;
|
||||
flatMapConcurLimit<U, V>(fn: (value: T) => Observable<U, V>, limit: number): Observable<U, V>;
|
||||
flatMapErrors<U, V>(transform: (error: S) => Observable<U, V>): Observable<U, V>;
|
||||
// Combine two streams
|
||||
filterBy<U>(otherObs: Observable<boolean, U>): Stream<T, S>;
|
||||
sampledBy<U, V, W>(otherObs: Observable<U, V>, combinator?: (a: T, b: U) => W): Stream<W, S>;
|
||||
skipUntilBy<U, V>(otherObs: Observable<U, V>): Stream<U, V>;
|
||||
takeUntilBy<U, V>(otherObs: Observable<U, V>): Stream<U, V>;
|
||||
bufferBy<U, V>(otherObs: Observable<U, V>, options?: { flushOnEnd: boolean }): Stream<T[], S>;
|
||||
bufferWhileBy<U>(otherObs: Observable<boolean, U>, options?: { flushOnEnd?: boolean, flushOnChange?: boolean }): Stream<T[], S>;
|
||||
awaiting<U, V>(otherObs: Observable<U, V>): Stream<boolean, S>;
|
||||
filterBy<U>(otherObs: Observable<boolean, U>): Observable<T, S>;
|
||||
sampledBy(otherObs: Observable<any, any>): Observable<T, S>;
|
||||
sampledBy<U, W>(otherObs: Observable<U, any>, combinator: (a: T, b: U) => W): Observable<W, S>;
|
||||
skipUntilBy<U, V>(otherObs: Observable<U, V>): Observable<U, V>;
|
||||
takeUntilBy<U, V>(otherObs: Observable<U, V>): Observable<U, V>;
|
||||
bufferBy<U, V>(otherObs: Observable<U, V>, options?: { flushOnEnd: boolean }): Observable<T[], S>;
|
||||
bufferWhileBy<U>(otherObs: Observable<boolean, U>, options?: { flushOnEnd?: boolean, flushOnChange?: boolean }): Observable<T[], S>;
|
||||
awaiting<U, V>(otherObs: Observable<U, V>): Observable<boolean, S>;
|
||||
}
|
||||
|
||||
export interface Property<T, S> extends Observable<T, S> {
|
||||
changes(): Stream<T, S>;
|
||||
// Modify an property
|
||||
map<U>(fn: (value: T) => U): Property<U, S>;
|
||||
filter(predicate?: (value: T) => boolean): Property<T, S>;
|
||||
take(n: number): Property<T, S>;
|
||||
takeWhile(predicate?: (value: T) => boolean): Property<T, S>;
|
||||
last(): Property<T, S>;
|
||||
skip(n: number): Property<T, S>;
|
||||
skipWhile(predicate?: (value: T) => boolean): Property<T, S>;
|
||||
skipDuplicates(comparator?: (a: T, b: T) => boolean): Property<T, S>;
|
||||
diff(fn?: (prev: T, next: T) => T, seed?: T): Property<T, S>;
|
||||
scan(fn: (prev: T, next: T) => T, seed?: T): Property<T, S>;
|
||||
delay(wait: number): Property<T, S>;
|
||||
throttle(wait: number, options?: { leading?: boolean, trailing?: boolean }): Property<T, S>;
|
||||
debounce(wait: number, options?: { immediate: boolean }): Property<T, S>;
|
||||
valuesToErrors<U>(handler?: (value: T) => { convert: boolean, error: U }): Property<never, S | U>;
|
||||
errorsToValues<U>(handler?: (error: S) => { convert: boolean, value: U }): Property<T | U, never>;
|
||||
mapErrors<U>(fn: (error: S) => U): Property<T, U>;
|
||||
filterErrors(predicate?: (error: S) => boolean): Property<T, S>;
|
||||
endOnError(): Property<T, S>;
|
||||
takeErrors(n: number): Stream<T, S>;
|
||||
ignoreValues(): Property<never, S>;
|
||||
ignoreErrors(): Property<T, never>;
|
||||
ignoreEnd(): Property<T, S>;
|
||||
beforeEnd<U>(fn: () => U): Property<T | U, S>;
|
||||
slidingWindow(max: number, mix?: number): Property<T[], S>;
|
||||
bufferWhile(predicate: (value: T) => boolean): Property<T[], S>;
|
||||
bufferWithCount(count: number, options?: { flushOnEnd: boolean }): Property<T[], S>;
|
||||
bufferWithTimeOrCount(interval: number, count: number, options?: { flushOnEnd: boolean }): Property<T[], S>;
|
||||
transduce<U>(transducer: any): Property<U, S>;
|
||||
withHandler<U, V>(handler: (emitter: Emitter<T, S>, event: Event<T | S>) => void): Property<U, S>;
|
||||
// Combine properties
|
||||
combine<U, V, W>(otherObs: Property<U, V>, combinator?: (value: T, ...values: U[]) => W): Property<W, S | V>;
|
||||
zip<U, V, W>(otherObs: Property<U, V>, combinator?: (value: T, ...values: U[]) => W): Property<W, S | V>;
|
||||
merge<U, V>(otherObs: Property<U, V>): Property<T | U, S | V>;
|
||||
concat<U, V>(otherObs: Property<U, V>): Property<T | U, S | V>;
|
||||
flatMap<U, V>(transform: (value: T) => Property<U, V>): Property<U, V>;
|
||||
flatMap<X extends T & Property<T, any>>(): Property<ValueOfAnObservable<X>, any>;
|
||||
flatMapLatest<U, V>(fn: (value: T) => Property<U, V>): Property<U, V>;
|
||||
flatMapLatest<X extends T & Property<T, any>>(): Property<ValueOfAnObservable<X>, any>;
|
||||
flatMapFirst<U, V>(fn: (value: T) => Property<U, V>): Property<U, V>;
|
||||
flatMapFirst<X extends T & Property<T, any>>(): Property<ValueOfAnObservable<X>, any>;
|
||||
flatMapConcat<U, V>(fn: (value: T) => Property<U, V>): Property<U, V>;
|
||||
flatMapConcurLimit<U, V>(fn: (value: T) => Property<U, V>, limit: number): Property<U, V>;
|
||||
flatMapErrors<U, V>(transform: (error: S) => Property<U, V>): Property<U, V>;
|
||||
// Combine two properties
|
||||
filterBy<U>(otherObs: Observable<boolean, U>): Property<T, S>;
|
||||
sampledBy<U, V, W>(otherObs: Observable<U, V>, combinator?: (a: T, b: U) => W): Property<W, S>;
|
||||
skipUntilBy<U, V>(otherObs: Observable<U, V>): Property<U, V>;
|
||||
takeUntilBy<U, V>(otherObs: Observable<U, V>): Property<U, V>;
|
||||
bufferBy<U, V>(otherObs: Observable<U, V>, options?: { flushOnEnd: boolean }): Property<T[], S>;
|
||||
bufferWhileBy<U>(otherObs: Observable<boolean, U>, options?: { flushOnEnd?: boolean, flushOnChange?: boolean }): Property<T[], S>;
|
||||
awaiting<U, V>(otherObs: Observable<U, V>): Property<boolean, S>;
|
||||
export class Stream<T, S> extends Observable<T, S> {
|
||||
|
||||
}
|
||||
|
||||
export interface ObservablePool<T, S> extends Observable<T, S> {
|
||||
export class Property<T, S> extends Observable<T, S> {
|
||||
|
||||
}
|
||||
|
||||
export class Pool<T, S> extends Observable<T, S> {
|
||||
plug(obs: Observable<T, S>): this;
|
||||
unPlug(obs: Observable<T, S>): this;
|
||||
unplug(obs: Observable<T, S>): this;
|
||||
}
|
||||
|
||||
export interface Event<T> {
|
||||
type: string;
|
||||
value: T;
|
||||
}
|
||||
export type Event<V,E> =
|
||||
{ type: 'value', value: V } |
|
||||
{ type: 'error', value: E } |
|
||||
{ type: 'end', value: void };
|
||||
|
||||
export interface Emitter<T, S> {
|
||||
emit(value: T): void;
|
||||
error(error: S): void;
|
||||
export interface Emitter<V, E> {
|
||||
value(value: V): boolean;
|
||||
event(event: Event<V, E>): boolean;
|
||||
error(e: E): boolean;
|
||||
end(): void;
|
||||
emitEvent(event: { type: string, value: T | S }): void;
|
||||
|
||||
// Deprecated methods
|
||||
emit(value: V): boolean;
|
||||
emitEvent(event: Event<V, E>): boolean;
|
||||
}
|
||||
|
||||
// Create a stream
|
||||
export declare function never(): Stream<never, never>;
|
||||
export declare function later<T>(wait: number, value: T): Stream<T, never>;
|
||||
export declare function interval<T>(interval: number, value: T): Stream<T, never>;
|
||||
export declare function sequentially<T>(interval: number, values: T[]): Stream<T, never>;
|
||||
export declare function fromPoll<T>(interval: number, fn: () => T): Stream<T, never>;
|
||||
export declare function withInterval<T, S>(interval: number, handler: (emitter: Emitter<T, S>) => void): Stream<T, S>;
|
||||
export declare function fromCallback<T>(fn: (callback: (value: T) => void) => void): Stream<T, never>;
|
||||
export declare function fromNodeCallback<T, S>(fn: (callback: (error: S, result: T) => void) => void): Stream<T, S>;
|
||||
export declare function fromEvents<T, S>(target: EventTarget | NodeJS.EventEmitter | { on: Function, off: Function }, eventName: string, transform?: (value: T) => S): Stream<T, S>;
|
||||
export declare function stream<T, S>(subscribe: (emitter: Emitter<T, S>) => Function | void): Stream<T, S>;
|
||||
export declare function fromESObservable<T, S>(observable: any): Stream<T, S>
|
||||
export function never(): Stream<never, never>;
|
||||
export function later<T>(wait: number, value: T): Stream<T, never>;
|
||||
export function interval<T>(interval: number, value: T): Stream<T, never>;
|
||||
export function sequentially<T>(interval: number, values: T[]): Stream<T, never>;
|
||||
export function fromPoll<T>(interval: number, fn: () => T): Stream<T, never>;
|
||||
export function withInterval<T, S>(interval: number, handler: (emitter: Emitter<T, S>) => void): Stream<T, S>;
|
||||
export function fromCallback<T>(fn: (callback: (value: T) => void) => void): Stream<T, never>;
|
||||
export function fromNodeCallback<T, S>(fn: (callback: (error: S, result: T) => void) => void): Stream<T, S>;
|
||||
export function fromEvents<T, S>(target: EventTarget | NodeJS.EventEmitter | { on: Function, off: Function }, eventName: string, transform?: (value: T) => S): Stream<T, S>;
|
||||
export function stream<T, S>(subscribe: (emitter: Emitter<T, S>) => Function | void): Stream<T, S>;
|
||||
export function fromESObservable<T, S>(observable: any): Stream<T, S>
|
||||
|
||||
// Create a property
|
||||
export declare function constant<T>(value: T): Property<T, never>;
|
||||
export declare function constantError<T>(error: T): Property<never, T>;
|
||||
export declare function fromPromise<T, S>(promise: Promise<T>): Property<T, S>;
|
||||
export function constant<T>(value: T): Property<T, never>;
|
||||
export function constantError<T>(error: T): Property<never, T>;
|
||||
export function fromPromise<T, S>(promise: Promise<T>): Property<T, S>;
|
||||
// Combine observables
|
||||
export declare function combine<T, S, U>(obss: Observable<T, S>[], passiveObss: Observable<T, S>[], combinator?: (...values: T[]) => U): Stream<U, S>;
|
||||
export declare function combine<T, S, U>(obss: Observable<T, S>[], combinator: (...values: T[]) => U): Stream<U, S>;
|
||||
export declare function combine<T extends { [name: string]: Observable<any, any> }>(obss: T): Stream<{ [P in keyof T]: ValueOfAnObservable<T[P]> }, any>;
|
||||
export declare function combine<T extends [Observable<any, any>], P extends keyof T>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>], any>;
|
||||
export declare function combine<T extends [Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>, ValueOfAnObservable<T[2]>, ValueOfAnObservable<T[3]>, ValueOfAnObservable<T[4]>, ValueOfAnObservable<T[5]>, ValueOfAnObservable<T[6]>, ValueOfAnObservable<T[7]>], any>;
|
||||
export declare function combine<T extends [Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>, ValueOfAnObservable<T[2]>, ValueOfAnObservable<T[3]>, ValueOfAnObservable<T[4]>, ValueOfAnObservable<T[5]>, ValueOfAnObservable<T[6]>], any>;
|
||||
export declare function combine<T extends [Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>, ValueOfAnObservable<T[2]>, ValueOfAnObservable<T[3]>, ValueOfAnObservable<T[4]>, ValueOfAnObservable<T[5]>], any>;
|
||||
export declare function combine<T extends [Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>, ValueOfAnObservable<T[2]>, ValueOfAnObservable<T[3]>, ValueOfAnObservable<T[4]>], any>;
|
||||
export declare function combine<T extends [Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>, ValueOfAnObservable<T[2]>, ValueOfAnObservable<T[3]>], any>;
|
||||
export declare function combine<T extends [Observable<any, any>, Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>, ValueOfAnObservable<T[2]>], any>;
|
||||
export declare function combine<T extends [Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>], any>;
|
||||
export declare function combine<T extends [Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>], any>;
|
||||
export declare function combine<T extends never[]>(obss: T): Stream<never, never>;
|
||||
export declare function zip<T, S, U>(obss: Observable<T, S>[], passiveObss?: Observable<T, S>[], combinator?: (...values: T[]) => U): Observable<U, S>;
|
||||
export declare function merge<T, S>(obss: Observable<T, S>[]): Observable<T, S>;
|
||||
export declare function concat<T, S>(obss: Observable<T, S>[]): Observable<T, S>;
|
||||
export declare function pool<T, S>(): ObservablePool<T, S>;
|
||||
export declare function repeat<T, S>(generator: (i: number) => Observable<T, S> | boolean): Observable<T, S>;
|
||||
export function combine<T, S, U>(obss: Observable<T, S>[], passiveObss: Observable<T, S>[], combinator?: (...values: T[]) => U): Stream<U, S>;
|
||||
export function combine<T, S, U>(obss: Observable<T, S>[], combinator: (...values: T[]) => U): Stream<U, S>;
|
||||
export function combine<T extends { [name: string]: Observable<any, any> }>(obss: T): Stream<{ [P in keyof T]: ValueOfAnObservable<T[P]> }, any>;
|
||||
export function combine<T extends [Observable<any, any>], P extends keyof T>(obss: T): Stream<[ValueOfAnObservable<T[0]>], any>;
|
||||
export function combine<T extends [Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>, ValueOfAnObservable<T[2]>, ValueOfAnObservable<T[3]>, ValueOfAnObservable<T[4]>, ValueOfAnObservable<T[5]>, ValueOfAnObservable<T[6]>, ValueOfAnObservable<T[7]>], any>;
|
||||
export function combine<T extends [Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>, ValueOfAnObservable<T[2]>, ValueOfAnObservable<T[3]>, ValueOfAnObservable<T[4]>, ValueOfAnObservable<T[5]>, ValueOfAnObservable<T[6]>], any>;
|
||||
export function combine<T extends [Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>, ValueOfAnObservable<T[2]>, ValueOfAnObservable<T[3]>, ValueOfAnObservable<T[4]>, ValueOfAnObservable<T[5]>], any>;
|
||||
export function combine<T extends [Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>, ValueOfAnObservable<T[2]>, ValueOfAnObservable<T[3]>, ValueOfAnObservable<T[4]>], any>;
|
||||
export function combine<T extends [Observable<any, any>, Observable<any, any>, Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>, ValueOfAnObservable<T[2]>, ValueOfAnObservable<T[3]>], any>;
|
||||
export function combine<T extends [Observable<any, any>, Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>, ValueOfAnObservable<T[2]>], any>;
|
||||
export function combine<T extends [Observable<any, any>, Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>, ValueOfAnObservable<T[1]>], any>;
|
||||
export function combine<T extends [Observable<any, any>]>(obss: T): Stream<[ValueOfAnObservable<T[0]>], any>;
|
||||
export function combine<T extends never[]>(obss: T): Stream<never, never>;
|
||||
export function combine<T extends[Observable<any, any>], P extends [Observable<any, any>], K>(obss: T, obssP: P, combinator: (a: T[0][''], b: P[0]['']) => K): Observable<K, any>;
|
||||
export function zip<T, S, U>(obss: Observable<T, S>[], passiveObss?: Observable<T, S>[], combinator?: (...values: T[]) => U): Observable<U, S>;
|
||||
export function merge<T, S>(obss: Observable<T, S>[]): Observable<T, S>;
|
||||
export function concat<T, S>(obss: Observable<T, S>[]): Observable<T, S>;
|
||||
export function pool<T, S>(): Pool<T, S>;
|
||||
export function repeat<T, S>(generator: (i: number) => Observable<T, S> | boolean): Observable<T, S>;
|
||||
|
||||
export var staticLand: {
|
||||
Observable: {
|
||||
ap<A, B, E1, E2>(obsF: Observable<(x: A) => B, E1>, obsV: Observable<A, E2>): Observable<B, E1|E2>;
|
||||
bimap<V1, E1, V2, E2>(fnE: (x: E1) => E2, fnV: (x: V1) => V2, obs: Observable<V1, E1>): Observable<V2, E2>;
|
||||
chain<V, V2, E, E2>(cb: (value: V) => Observable<V2, E2>, s: Observable<V, E>): Observable<V2, E | E2>;
|
||||
concat<V1, E1, V2, E2>(obs1: Observable<V1, E1>, obs2: Observable<V2, E2>): Observable<V1 | V2, E1 | E2>;
|
||||
empty(): Observable<never, never>;
|
||||
map<V, V2, E>(cb: (value: V) => V2, s: Observable<V, E>): Observable<V2, E>;
|
||||
of<V>(value: V): Observable<V, never>;
|
||||
}
|
||||
}
|
||||
|
||||
declare var kefir: {
|
||||
Observable: typeof Observable;
|
||||
Pool: typeof Pool;
|
||||
Stream: typeof Stream;
|
||||
Property: typeof Property;
|
||||
|
||||
never: typeof never,
|
||||
later: typeof later,
|
||||
interval: typeof interval,
|
||||
sequentially: typeof sequentially,
|
||||
fromPoll: typeof fromPoll,
|
||||
withInterval: typeof withInterval,
|
||||
fromCallback: typeof fromCallback,
|
||||
fromNodeCallback: typeof fromNodeCallback,
|
||||
fromEvents: typeof fromEvents,
|
||||
stream: typeof stream,
|
||||
fromESObservable: typeof fromESObservable,
|
||||
constant: typeof constant,
|
||||
constantError: typeof constantError,
|
||||
fromPromise: typeof fromPromise,
|
||||
combine: typeof combine,
|
||||
zip: typeof zip,
|
||||
merge: typeof merge,
|
||||
concat: typeof concat,
|
||||
pool: typeof pool,
|
||||
repeat: typeof repeat,
|
||||
|
||||
staticLand: typeof staticLand
|
||||
};
|
||||
|
||||
export default kefir;
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
|
||||
import * as Kefir from 'kefir';
|
||||
import { Observable, ObservablePool, Stream, Property, Event, Emitter } from 'kefir';
|
||||
import { Observable, Pool, Stream, Property, Event, Emitter } from 'kefir';
|
||||
|
||||
//Create a stream
|
||||
{
|
||||
@@ -130,7 +130,7 @@ import { Observable, ObservablePool, Stream, Property, Event, Emitter } from 'ke
|
||||
var myTransducer: any;
|
||||
let observable28: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3, 4, 5, 6]).transduce<number>(myTransducer);
|
||||
}
|
||||
let observable28: Stream<number | string, void> = Kefir.sequentially(100, [0, 1, 2, 3]).withHandler<number | string, void>((emitter: Emitter<string | number, void>, event: Event<number>) => {
|
||||
let observable28: Stream<number | string, void> = Kefir.sequentially(100, [0, 1, 2, 3]).withHandler<number | string, void>((emitter: Emitter<string | number, void>, event: Event<number, void>) => {
|
||||
if (event.type === 'end') {
|
||||
emitter.emit('bye');
|
||||
emitter.end();
|
||||
@@ -141,6 +141,9 @@ import { Observable, ObservablePool, Stream, Property, Event, Emitter } from 'ke
|
||||
}
|
||||
}
|
||||
});
|
||||
type First = 'first';
|
||||
type Second = 'second';
|
||||
let observable32: Stream<First, void> = Kefir.sequentially<First | Second>(100, ['first', 'second']).filter((value): value is First => value === 'first');
|
||||
}
|
||||
|
||||
// Combine observables
|
||||
@@ -177,7 +180,7 @@ import { Observable, ObservablePool, Stream, Property, Event, Emitter } from 'ke
|
||||
let a: Stream<number, void> = Kefir.sequentially(100, [0, 1, 2]);
|
||||
let b: Stream<number, void> = Kefir.sequentially(100, [0, 1, 2]).delay(30);
|
||||
let c: Observable<number, void> = Kefir.sequentially(100, [0, 1, 2]).delay(60);
|
||||
let pool: ObservablePool<number, void> = Kefir.pool<number, void>();
|
||||
let pool: Pool<number, void> = Kefir.pool<number, void>();
|
||||
pool.plug(a);
|
||||
pool.plug(b);
|
||||
pool.plug(c);
|
||||
@@ -207,7 +210,7 @@ import { Observable, ObservablePool, Stream, Property, Event, Emitter } from 'ke
|
||||
{
|
||||
let a: Property<number, void> = Kefir.sequentially(200, [2, 3]).toProperty(() => 1);
|
||||
let b: Stream<number, void> = Kefir.interval(100, 0).delay(40).take(5);
|
||||
let observable02: Property<number, void> = a.sampledBy<number, void, number>(b)
|
||||
let observable02: Property<number, void> = a.sampledBy(b)
|
||||
}
|
||||
{
|
||||
let foo: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3, 4]);
|
||||
|
||||
Reference in New Issue
Block a user