2016-04-28 20:50:03 -04:00
|
|
|
import {global, noop} from './lang';
|
|
|
|
export {PromiseWrapper, PromiseCompleter} from './promise';
|
2015-11-14 03:02:57 -05:00
|
|
|
|
2015-12-12 11:29:02 -05:00
|
|
|
import {Observable} from 'rxjs/Observable';
|
2015-11-30 20:22:52 -05:00
|
|
|
import {Subject} from 'rxjs/Subject';
|
|
|
|
|
2016-02-17 17:05:47 -05:00
|
|
|
import {PromiseObservable} from 'rxjs/observable/PromiseObservable';
|
2015-12-04 12:09:57 -05:00
|
|
|
import {toPromise} from 'rxjs/operator/toPromise';
|
2015-11-30 20:22:52 -05:00
|
|
|
|
2015-12-12 11:29:02 -05:00
|
|
|
export {Observable} from 'rxjs/Observable';
|
2015-11-30 20:22:52 -05:00
|
|
|
export {Subject} from 'rxjs/Subject';
|
|
|
|
|
2015-05-19 10:47:30 -04:00
|
|
|
export class TimerWrapper {
|
2016-02-01 13:29:42 -05:00
|
|
|
static setTimeout(fn: (...args: any[]) => void, millis: number): number {
|
2015-10-09 20:21:25 -04:00
|
|
|
return global.setTimeout(fn, millis);
|
|
|
|
}
|
2016-02-01 13:29:42 -05:00
|
|
|
static clearTimeout(id: number): void { global.clearTimeout(id); }
|
2015-05-12 10:28:57 -04:00
|
|
|
|
2016-02-01 13:29:42 -05:00
|
|
|
static setInterval(fn: (...args: any[]) => void, millis: number): number {
|
2015-08-20 19:25:34 -04:00
|
|
|
return global.setInterval(fn, millis);
|
|
|
|
}
|
2016-02-01 13:29:42 -05:00
|
|
|
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
|
2016-04-12 12:40:37 -04:00
|
|
|
static subscribe<T>(emitter: any, onNext: (value: T) => void, onError?: (exception: any) => void,
|
|
|
|
onComplete: () => void = () => {}): Object {
|
|
|
|
onError = (typeof onError === "function") && onError || noop;
|
|
|
|
onComplete = (typeof onComplete === "function") && onComplete || noop;
|
2015-10-24 21:48:43 -04:00
|
|
|
return emitter.subscribe({next: onNext, error: onError, complete: onComplete});
|
2015-04-14 17:34:41 -04:00
|
|
|
}
|
|
|
|
|
2015-12-04 18:33:41 -05:00
|
|
|
static isObservable(obs: any): boolean { return !!obs.subscribe; }
|
2015-04-19 15:45:08 -04:00
|
|
|
|
2015-10-19 17:41:15 -04:00
|
|
|
/**
|
|
|
|
* Returns whether `obs` has any subscribers listening to events.
|
|
|
|
*/
|
2015-10-24 21:48:43 -04:00
|
|
|
static hasSubscribers(obs: EventEmitter<any>): boolean { return obs.observers.length > 0; }
|
2015-10-19 17:41:15 -04:00
|
|
|
|
2015-09-11 18:38:09 -04:00
|
|
|
static dispose(subscription: any) { subscription.unsubscribe(); }
|
2015-04-19 15:45:08 -04:00
|
|
|
|
2015-11-16 02:58:59 -05:00
|
|
|
/**
|
|
|
|
* @deprecated - use callEmit() instead
|
|
|
|
*/
|
2015-10-24 21:48:43 -04:00
|
|
|
static callNext(emitter: EventEmitter<any>, value: any) { emitter.next(value); }
|
2015-04-14 17:34:41 -04:00
|
|
|
|
2015-11-16 02:58:59 -05:00
|
|
|
static callEmit(emitter: EventEmitter<any>, value: any) { emitter.emit(value); }
|
|
|
|
|
2015-10-24 21:48:43 -04:00
|
|
|
static callError(emitter: EventEmitter<any>, error: any) { emitter.error(error); }
|
2015-04-14 17:34:41 -04:00
|
|
|
|
2015-10-24 21:48:43 -04:00
|
|
|
static callComplete(emitter: EventEmitter<any>) { emitter.complete(); }
|
2015-11-02 12:58:42 -05:00
|
|
|
|
|
|
|
static fromPromise(promise: Promise<any>): Observable<any> {
|
2015-12-04 12:09:57 -05:00
|
|
|
return PromiseObservable.create(promise);
|
2015-11-02 12:58:42 -05:00
|
|
|
}
|
2015-11-02 14:57:31 -05:00
|
|
|
|
2015-12-04 12:09:57 -05:00
|
|
|
static toPromise(obj: Observable<any>): Promise<any> { return toPromise.call(obj); }
|
2015-04-14 17:34:41 -04:00
|
|
|
}
|
|
|
|
|
2015-04-01 13:45:56 -04:00
|
|
|
/**
|
2015-09-30 23:59:23 -04:00
|
|
|
* Use by directives and components to emit custom Events.
|
2015-09-03 19:17:23 -04:00
|
|
|
*
|
2015-10-19 10:37:32 -04:00
|
|
|
* ### Examples
|
2015-09-03 19:17:23 -04:00
|
|
|
*
|
|
|
|
* In the following example, `Zippy` alternatively emits `open` and `close` events when its
|
|
|
|
* title gets clicked:
|
|
|
|
*
|
|
|
|
* ```
|
2015-10-11 10:41:19 -04:00
|
|
|
* @Component({
|
|
|
|
* selector: 'zippy',
|
|
|
|
* template: `
|
2015-09-03 19:17:23 -04:00
|
|
|
* <div class="zippy">
|
|
|
|
* <div (click)="toggle()">Toggle</div>
|
|
|
|
* <div [hidden]="!visible">
|
|
|
|
* <ng-content></ng-content>
|
|
|
|
* </div>
|
|
|
|
* </div>`})
|
|
|
|
* export class Zippy {
|
|
|
|
* visible: boolean = true;
|
2015-11-19 17:10:50 -05:00
|
|
|
* @Output() open: EventEmitter<any> = new EventEmitter();
|
|
|
|
* @Output() close: EventEmitter<any> = new EventEmitter();
|
2015-09-03 19:17:23 -04:00
|
|
|
*
|
|
|
|
* toggle() {
|
|
|
|
* this.visible = !this.visible;
|
|
|
|
* if (this.visible) {
|
2015-11-16 02:58:59 -05:00
|
|
|
* this.open.emit(null);
|
2015-09-03 19:17:23 -04:00
|
|
|
* } else {
|
2015-11-16 02:58:59 -05:00
|
|
|
* this.close.emit(null);
|
2015-09-03 19:17:23 -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-10-24 21:48:43 -04:00
|
|
|
export class EventEmitter<T> extends Subject<T> {
|
2016-05-19 18:29:50 -04:00
|
|
|
// TODO: mark this as internal once all the facades are gone
|
|
|
|
// we can't mark it as internal now because EventEmitter exported via @angular/core would not
|
|
|
|
// contain this property making it incompatible with all the code that uses EventEmitter via
|
|
|
|
// facades, which are local to the code and do not have this property stripped.
|
|
|
|
__isAsync: boolean;
|
2015-10-19 17:41:15 -04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates an instance of [EventEmitter], which depending on [isAsync],
|
|
|
|
* delivers events synchronously or asynchronously.
|
|
|
|
*/
|
|
|
|
constructor(isAsync: boolean = true) {
|
|
|
|
super();
|
2016-05-19 18:29:50 -04:00
|
|
|
this.__isAsync = isAsync;
|
2015-10-19 17:41:15 -04:00
|
|
|
}
|
2015-09-11 18:38:09 -04:00
|
|
|
|
2015-11-16 02:58:59 -05:00
|
|
|
emit(value: T) { super.next(value); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @deprecated - use .emit(value) instead
|
|
|
|
*/
|
|
|
|
next(value: any) { super.next(value); }
|
|
|
|
|
2015-10-24 21:48:43 -04:00
|
|
|
subscribe(generatorOrNext?: any, error?: any, complete?: any): any {
|
2015-10-29 22:57:28 -04:00
|
|
|
let schedulerFn;
|
|
|
|
let errorFn = (err: any) => null;
|
|
|
|
let completeFn = () => null;
|
|
|
|
|
2015-10-24 21:48:43 -04:00
|
|
|
if (generatorOrNext && typeof generatorOrNext === 'object') {
|
2016-05-19 18:29:50 -04:00
|
|
|
schedulerFn = this.__isAsync ? (value) => { setTimeout(() => generatorOrNext.next(value)); } :
|
2015-10-29 22:57:28 -04:00
|
|
|
(value) => { generatorOrNext.next(value); };
|
|
|
|
|
|
|
|
if (generatorOrNext.error) {
|
2016-05-19 18:29:50 -04:00
|
|
|
errorFn = this.__isAsync ? (err) => { setTimeout(() => generatorOrNext.error(err)); } :
|
2015-10-29 22:57:28 -04:00
|
|
|
(err) => { generatorOrNext.error(err); };
|
|
|
|
}
|
|
|
|
|
|
|
|
if (generatorOrNext.complete) {
|
2016-05-19 18:29:50 -04:00
|
|
|
completeFn = this.__isAsync ? () => { setTimeout(() => generatorOrNext.complete()); } :
|
2015-10-29 22:57:28 -04:00
|
|
|
() => { generatorOrNext.complete(); };
|
|
|
|
}
|
2015-10-24 21:48:43 -04:00
|
|
|
} else {
|
2016-05-19 18:29:50 -04:00
|
|
|
schedulerFn = this.__isAsync ? (value) => { setTimeout(() => generatorOrNext(value)); } :
|
2015-10-29 22:57:28 -04:00
|
|
|
(value) => { generatorOrNext(value); };
|
|
|
|
|
|
|
|
if (error) {
|
|
|
|
errorFn =
|
2016-05-19 18:29:50 -04:00
|
|
|
this.__isAsync ? (err) => { setTimeout(() => error(err)); } : (err) => { error(err); };
|
2015-10-29 22:57:28 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (complete) {
|
|
|
|
completeFn =
|
2016-05-19 18:29:50 -04:00
|
|
|
this.__isAsync ? () => { setTimeout(() => complete()); } : () => { complete(); };
|
2015-10-29 22:57:28 -04:00
|
|
|
}
|
2015-10-24 21:48:43 -04:00
|
|
|
}
|
2015-10-29 22:57:28 -04:00
|
|
|
|
|
|
|
return super.subscribe(schedulerFn, errorFn, completeFn);
|
2015-04-14 17:34:41 -04:00
|
|
|
}
|
2016-02-01 13:29:42 -05:00
|
|
|
}
|