2015-09-04 01:01:36 -04:00
|
|
|
///<reference path="../../../typings/tsd.d.ts" />
|
2015-08-20 17:28:25 -04:00
|
|
|
import {global, isPresent} from 'angular2/src/core/facade/lang';
|
2015-04-01 13:45:56 -04:00
|
|
|
import * as Rx from 'rx';
|
|
|
|
|
2015-06-24 01:02:20 -04:00
|
|
|
export {Promise};
|
2015-04-24 18:19:11 -04:00
|
|
|
|
2015-06-26 14:10:52 -04:00
|
|
|
export interface PromiseCompleter<R> {
|
|
|
|
promise: Promise<R>;
|
2015-08-06 12:52:33 -04:00
|
|
|
resolve: (value?: R | PromiseLike<R>) => void;
|
2015-06-26 14:10:52 -04:00
|
|
|
reject: (error?: any, stackTrace?: string) => void;
|
|
|
|
}
|
|
|
|
|
2015-04-01 13:45:56 -04:00
|
|
|
export class PromiseWrapper {
|
2015-07-07 23:03:00 -04:00
|
|
|
static resolve<T>(obj: T): Promise<T> { return Promise.resolve(obj); }
|
2015-04-01 13:45:56 -04:00
|
|
|
|
2015-07-07 23:03:00 -04:00
|
|
|
static reject(obj: any, _): Promise<any> { return Promise.reject(obj); }
|
2015-04-01 13:45:56 -04:00
|
|
|
|
|
|
|
// Note: We can't rename this method into `catch`, as this is not a valid
|
|
|
|
// method name in Dart.
|
2015-08-06 12:52:33 -04:00
|
|
|
static catchError<T>(promise: Promise<T>,
|
|
|
|
onError: (error: any) => T | PromiseLike<T>): Promise<T> {
|
2015-04-01 13:45:56 -04:00
|
|
|
return promise.catch(onError);
|
|
|
|
}
|
|
|
|
|
2015-08-28 14:29:19 -04:00
|
|
|
static all(promises: any[]): Promise<any> {
|
2015-04-01 13:45:56 -04:00
|
|
|
if (promises.length == 0) return Promise.resolve([]);
|
|
|
|
return Promise.all(promises);
|
|
|
|
}
|
|
|
|
|
2015-08-06 12:52:33 -04:00
|
|
|
static then<T, U>(promise: Promise<T>, success: (value: T) => U | PromiseLike<U>,
|
|
|
|
rejection?: (error: any, stack?: any) => U | PromiseLike<U>): Promise<U> {
|
2015-04-01 13:45:56 -04:00
|
|
|
return promise.then(success, rejection);
|
|
|
|
}
|
|
|
|
|
2015-06-26 18:58:52 -04:00
|
|
|
static wrap<T>(computation: () => T): Promise<T> {
|
|
|
|
return new Promise((res, rej) => {
|
|
|
|
try {
|
|
|
|
res(computation());
|
|
|
|
} catch (e) {
|
|
|
|
rej(e);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2015-06-26 14:10:52 -04:00
|
|
|
static completer(): PromiseCompleter<any> {
|
2015-04-01 13:45:56 -04:00
|
|
|
var resolve;
|
|
|
|
var reject;
|
|
|
|
|
|
|
|
var p = new Promise(function(res, rej) {
|
|
|
|
resolve = res;
|
|
|
|
reject = rej;
|
|
|
|
});
|
|
|
|
|
|
|
|
return {promise: p, resolve: resolve, reject: reject};
|
|
|
|
}
|
2015-05-19 10:47:30 -04:00
|
|
|
}
|
2015-04-01 13:45:56 -04:00
|
|
|
|
2015-05-19 10:47:30 -04:00
|
|
|
export class TimerWrapper {
|
2015-08-20 19:25:34 -04:00
|
|
|
static setTimeout(fn: Function, millis: number): number { return global.setTimeout(fn, millis); }
|
|
|
|
static clearTimeout(id: number): void { global.clearTimeout(id); }
|
2015-05-12 10:28:57 -04:00
|
|
|
|
2015-08-20 19:25:34 -04:00
|
|
|
static setInterval(fn: Function, millis: number): number {
|
|
|
|
return global.setInterval(fn, millis);
|
|
|
|
}
|
|
|
|
static clearInterval(id: number): void { global.clearInterval(id); }
|
2015-04-01 13:45:56 -04:00
|
|
|
}
|
|
|
|
|
2015-04-14 17:34:41 -04:00
|
|
|
export class ObservableWrapper {
|
2015-08-06 12:52:33 -04:00
|
|
|
// TODO(vsavkin): when we use rxnext, try inferring the generic type from the first arg
|
2015-07-07 23:03:00 -04:00
|
|
|
static subscribe<T>(emitter: Observable, onNext: (value: T) => void,
|
|
|
|
onThrow: (exception: any) => void = null,
|
|
|
|
onReturn: () => void = null): Object {
|
2015-04-14 17:34:41 -04:00
|
|
|
return emitter.observer({next: onNext, throw: onThrow, return: onReturn});
|
|
|
|
}
|
|
|
|
|
2015-04-19 15:45:08 -04:00
|
|
|
static isObservable(obs: any): boolean { return obs instanceof Observable; }
|
|
|
|
|
|
|
|
static dispose(subscription: any) { subscription.dispose(); }
|
|
|
|
|
2015-04-14 17:34:41 -04:00
|
|
|
static callNext(emitter: EventEmitter, value: any) { emitter.next(value); }
|
|
|
|
|
|
|
|
static callThrow(emitter: EventEmitter, error: any) { emitter.throw(error); }
|
|
|
|
|
|
|
|
static callReturn(emitter: EventEmitter) { emitter.return (null); }
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: vsavkin change to interface
|
|
|
|
export class Observable {
|
2015-05-01 17:05:19 -04:00
|
|
|
observer(generator: any): Object { return null; }
|
2015-04-14 17:34:41 -04:00
|
|
|
}
|
|
|
|
|
2015-04-01 13:45:56 -04:00
|
|
|
/**
|
|
|
|
* Use Rx.Observable but provides an adapter to make it work as specified here:
|
|
|
|
* https://github.com/jhusain/observable-spec
|
|
|
|
*
|
|
|
|
* Once a reference implementation of the spec is available, switch to it.
|
|
|
|
*/
|
2015-04-14 17:34:41 -04:00
|
|
|
export class EventEmitter extends Observable {
|
|
|
|
_subject: Rx.Subject<any>;
|
2015-04-27 19:11:20 -04:00
|
|
|
_immediateScheduler;
|
2015-04-01 13:45:56 -04:00
|
|
|
|
2015-04-14 17:34:41 -04:00
|
|
|
constructor() {
|
|
|
|
super();
|
2015-08-14 18:05:56 -04:00
|
|
|
this._subject = new Rx.Subject<any>();
|
|
|
|
this._immediateScheduler = (<any>Rx.Scheduler).immediate;
|
2015-04-01 13:45:56 -04:00
|
|
|
}
|
|
|
|
|
2015-07-07 23:03:00 -04:00
|
|
|
observer(generator: any): Rx.IDisposable {
|
2015-04-27 19:11:20 -04:00
|
|
|
return this._subject.observeOn(this._immediateScheduler)
|
2015-04-14 17:34:41 -04:00
|
|
|
.subscribe((value) => { setTimeout(() => generator.next(value)); },
|
|
|
|
(error) => generator.throw ? generator.throw(error) : null,
|
|
|
|
() => generator.return ? generator.return () : null);
|
|
|
|
}
|
2015-04-01 13:45:56 -04:00
|
|
|
|
2015-04-14 17:34:41 -04:00
|
|
|
toRx(): Rx.Observable<any> { return this._subject; }
|
2015-04-01 13:45:56 -04:00
|
|
|
|
2015-07-07 23:03:00 -04:00
|
|
|
next(value: any) { this._subject.onNext(value); }
|
2015-04-14 17:34:41 -04:00
|
|
|
|
2015-07-07 23:03:00 -04:00
|
|
|
throw(error: any) { this._subject.onError(error); }
|
2015-04-14 17:34:41 -04:00
|
|
|
|
2015-07-07 23:03:00 -04:00
|
|
|
return (value?: any) { this._subject.onCompleted(); }
|
2015-04-27 19:11:20 -04:00
|
|
|
}
|