kylefang/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/zhigang1992/DefinitelyTyped.git synced 2026-03-29 17:08:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

Update kefir.d.ts 2.8.1 -> 3.2.0

Browse Source
This commit is contained in:
Aya Morisawa
2016-01-02 15:50:07 +09:00
parent 7a3d694403
commit 02ac8e494e
2 changed files with 43 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
kefir/kefir-tests.ts
View File

@@ -30,7 +30,7 @@ import { Observable, ObservablePool, Stream, Property, Event, Emitter } from 'ke
let stream10: Stream<number, void> = Kefir.stream<number, void>(emitter => {
let count = 0;
emitter.emit(count);
let intervalId = setInterval(() => {
count++;
if (count < 4) {
@@ -39,7 +39,7 @@ import { Observable, ObservablePool, Stream, Property, Event, Emitter } from 'ke
emitter.end();
}
}, 1000);
return () => clearInterval(intervalId);
});
}
@@ -77,6 +77,7 @@ import { Observable, ObservablePool, Stream, Property, Event, Emitter } from 'ke
let observable01: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).map(x => x + 1);
let observable02: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).filter(x => x > 1);
let observable03: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).take(2);
let observable29: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).takeErrors(2);
let observable04: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).takeWhile(x => x < 3);
let observable05: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).last();
let observable06: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).skip(2);
@@ -103,14 +104,16 @@ import { Observable, ObservablePool, Stream, Property, Event, Emitter } from 'ke
}).endOnError();
let observable22: Stream<void, number> = Kefir.sequentially(100, [0, -1, 2, -3]).valuesToErrors(x => {
return {convert: x < 0, error: x};
}).skipValues();
}).ignoreValues();
let observable23: Stream<void, void> = Kefir.sequentially(100, [0, -1, 2, -3]).valuesToErrors(x => {
return {convert: x < 0, error: x};
}).skipErrors();
let observable24: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).skipEnd();
}).ignoreErrors();
let observable24: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).ignoreEnd();
let ovservable25: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).beforeEnd(() => 0);
let observable26: Stream<number[], void> = Kefir.sequentially(100, [1, 2, 3, 4, 5]).slidingWindow(3, 2)
let observable27: Stream<number[], void> = Kefir.sequentially(100, [1, 2, 3, 4, 5]).bufferWhile(x => x !== 3);
let observable30: Stream<number[], void> = Kefir.sequentially(100, [1, 2, 3, 4, 5]).bufferWithCount(2);
let observable31: Stream<number[], void> = Kefir.sequentially(100, [1, 2, 3, 4, 5]).bufferWithTimeOrCount(330, 10);
{
var myTransducer: any;
let observable28: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3, 4, 5, 6]).transduce<number>(myTransducer);

64
kefir/kefir.d.ts vendored
View File

@@ -1,4 +1,4 @@
// Type definitions for Kefir 2.8.1
// Type definitions for Kefir 3.2.0
// Project: http://rpominov.github.io/kefir/
// Definitions by: Aya Morisawa <https://github.com/AyaMorisawa>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -6,7 +6,7 @@
/// <reference path="../node/node.d.ts" />
declare module "kefir" {
export interface Observable<T, S> {
// Subscribe / add side effects
onValue(callback: (value: T) => void): void;
@@ -19,12 +19,14 @@ declare module "kefir" {
offAny(callback: (event: Event<T | S>) => void): void;
log(name?: string): void;
offLog(name?: string): void;
flatten<U>(transformer?: (value: T) => U[]): Stream<U, S>;
toPromise(PromiseConstructor?: any): any;
toESObservable(): any;
}
export interface Stream<T, S> extends Observable<T, S> {
toProperty(getCurrent?: () => T): Property<T, S>;
// Modify an stream
map<U>(fn: (value: T) => U): Stream<U, S>;
filter(predicate?: (value: T) => boolean): Stream<T, S>;
@@ -36,24 +38,26 @@ declare module "kefir" {
skipDuplicates(comparator?: (a: T, b: T) => boolean): Stream<T, S>;
diff(fn?: (prev: T, next: T) => T, seed?: T): Stream<T, S>;
scan(fn: (prev: T, next: T) => T, seed?: T): Stream<T, S>;
flatten<U>(transformer?: (value: T) => U[]): Stream<U, S>;
delay(wait: number): Stream<T, S>;
throttle(wait: number, options?: {leading: boolean, trailing: boolean}): Stream<T, S>;
throttle(wait: number, options?: {leading?: boolean, trailing?: boolean}): Stream<T, S>;
debounce(wait: number, options?: {immediate: boolean}): Stream<T, S>;
valuesToErrors<U>(handler?: (value: T) => {convert: boolean, error: U}): Stream<void, S | U>;
errorsToValues<U>(handler?: (error: S) => {convert: boolean, value: U}): Stream<T | U, void>;
mapErrors<U>(fn: (error: S) => U): Stream<T, U>;
filterErrors(predicate?: (error: S) => boolean): Stream<T, S>;
endOnError(): Stream<T, S>;
skipValues(): Stream<void, S>;
skipErrors(): Stream<T, void>;
skipEnd(): Stream<T, S>;
takeErrors(n: number): Stream<T, S>;
ignoreValues(): Stream<void, S>;
ignoreErrors(): Stream<T, void>;
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>;
// 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>;
@@ -65,20 +69,20 @@ declare module "kefir" {
flatMapConcat<U, V>(fn: (value: T) => Stream<U, V>): Stream<U, V>;
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 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>): 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>;
}
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>;
@@ -90,24 +94,26 @@ declare module "kefir" {
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>;
flatten<U>(transformer?: (value: T) => U[]): Property<U, S>;
delay(wait: number): Property<T, S>;
throttle(wait: number, options?: {leading: boolean, trailing: boolean}): 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<void, S | U>;
errorsToValues<U>(handler?: (error: S) => {convert: boolean, value: U}): Property<T | U, void>;
mapErrors<U>(fn: (error: S) => U): Property<T, U>;
filterErrors(predicate?: (error: S) => boolean): Property<T, S>;
endOnError(): Property<T, S>;
skipValues(): Property<void, S>;
skipErrors(): Property<T, void>;
skipEnd(): Property<T, S>;
takeErrors(n: number): Stream<T, S>;
ignoreValues(): Property<void, S>;
ignoreErrors(): Property<T, void>;
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>;
@@ -119,35 +125,34 @@ declare module "kefir" {
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>): 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 interface ObservablePool<T, S> extends Observable<T, S> {
plug(obs: Observable<T, S>): void;
unPlug(obs: Observable<T, S>): void;
}
export interface Event<T> {
type: string;
value: T;
current: boolean;
}
export interface Emitter<T, S> {
emit(value: T): void;
error(error: S): void;
end(): void;
emitEvent(event: {type: string, value: T | S}): void;
}
// Create a stream
export function never(): Stream<void, void>;
export function later<T>(wait: number, value: T): Stream<T, void>;
@@ -159,12 +164,13 @@ declare module "kefir" {
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 function constant<T>(value: T): Property<T, void>;
export function constantError<T>(error: T): Property<void, T>;
export function fromPromise<T, S>(promise: any): Property<T, S>;
// Combine observables
export function combine<T, S, U>(obss: Observable<T, S>[], passiveObss: Observable<T, S>[], combinator?: (...values: T[]) => U): Observable<U, S>;
export function combine<T, S, U>(obss: Observable<T, S>[], combinator?: (...values: T[]) => U): Observable<U, S>;