angular-cn/modules/angular2/src/facade/async.ts

84 lines
2.8 KiB
TypeScript
Raw Normal View History

/// <reference path="../../typings/es6-promise/es6-promise.d.ts" />
/// <reference path="../../typings/rx/rx.all.d.ts" />
// HACK: workaround for Traceur behavior.
// It expects all transpiled modules to contain this marker.
// TODO: remove this when we no longer use traceur
export var __esModule = true;
import {int, global, isPresent} from 'angular2/src/facade/lang';
import {List} from 'angular2/src/facade/collection';
import * as Rx from 'rx';
export class PromiseWrapper {
static resolve(obj): Promise<any> { return Promise.resolve(obj); }
static reject(obj): Promise<any> { return Promise.reject(obj); }
// Note: We can't rename this method into `catch`, as this is not a valid
// method name in Dart.
static catchError<T>(promise: Promise<T>, onError: (error: any) => T | Thenable<T>): Promise<T> {
return promise.catch(onError);
}
static all(promises: List<Promise<any>>): Promise<any> {
if (promises.length == 0) return Promise.resolve([]);
return Promise.all(promises);
}
static then<T>(promise: Promise<T>, success: (value: any) => T | Thenable<T>,
rejection: (error: any) => T | Thenable<T>): Promise<T> {
return promise.then(success, rejection);
}
static completer() {
var resolve;
var reject;
var p = new Promise(function(res, rej) {
resolve = res;
reject = rej;
});
return {promise: p, resolve: resolve, reject: reject};
}
static setTimeout(fn: Function, millis: int) { global.setTimeout(fn, millis); }
static isPromise(maybePromise): boolean { return maybePromise instanceof Promise; }
}
/**
* 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.
*/
type Observable = Rx.Observable<any>;
type ObservableController = Rx.Subject<any>;
export class ObservableWrapper {
static createController(): Rx.Subject<any> { return new Rx.Subject(); }
static createObservable<T>(subject: Rx.Subject<T>): Rx.Observable<T> { return subject; }
static subscribe(observable: Rx.Observable<any>, generatorOrOnNext, onThrow = null,
onReturn = null) {
if (isPresent(generatorOrOnNext.next)) {
return observable.observeOn(Rx.Scheduler.timeout)
.subscribe((value) => generatorOrOnNext.next(value),
(error) => generatorOrOnNext.throw(error), () => generatorOrOnNext.return ());
} else {
return observable.observeOn(Rx.Scheduler.timeout)
.subscribe(generatorOrOnNext, onThrow, onReturn);
}
}
static callNext(subject: Rx.Subject<any>, value: any) { subject.onNext(value); }
static callThrow(subject: Rx.Subject<any>, error: any) { subject.onError(error); }
static callReturn(subject: Rx.Subject<any>) { subject.onCompleted(); }
}