diff --git a/spec/exports-spec.ts b/spec/exports-spec.ts index 96e6a4ac34..b5e1da97ba 100644 --- a/spec/exports-spec.ts +++ b/spec/exports-spec.ts @@ -19,7 +19,7 @@ import { onErrorResumeNext } from '../src/internal/observable/onErrorResumeNext' import { pairs } from '../src/internal/observable/pairs'; import { race } from '../src/internal/observable/race'; import { range } from '../src/internal/observable/range'; -import { _throw } from '../src/internal/observable/throw'; +import { throwError } from '../src/internal/observable/throwError'; import { timer } from '../src/internal/observable/timer'; import { using } from '../src/internal/observable/using'; import { zip } from '../src/internal/observable/zip'; @@ -106,8 +106,8 @@ describe('exports', () => { expect(range).to.equal(Rx.Observable.range); }); - it('should have rxjs/observable/throw', () => { - expect(_throw).to.equal(Rx.Observable.throw); + it('should have rxjs/observable/throwError', () => { + expect(throwError).to.equal(Rx.Observable.throw); }); it('should have rxjs/observable/timer', () => { diff --git a/spec/observables/throw-spec.ts b/spec/observables/throwError-spec.ts similarity index 54% rename from spec/observables/throw-spec.ts rename to spec/observables/throwError-spec.ts index 882b4f4189..8df27b47d1 100644 --- a/spec/observables/throw-spec.ts +++ b/spec/observables/throwError-spec.ts @@ -1,24 +1,23 @@ import { expect } from 'chai'; import * as Rx from '../../src/Rx'; -import { ErrorObservable } from '../../src/internal/observable/ErrorObservable'; +import { throwError } from '../../src/create'; import marbleTestingSignature = require('../helpers/marble-testing'); // tslint:disable-line:no-require-imports -declare const { asDiagram }; +declare const asDiagram: any; declare const expectObservable: typeof marbleTestingSignature.expectObservable; declare const rxTestScheduler: Rx.TestScheduler; -const Observable = Rx.Observable; /** @test {throw} */ -describe('Observable.throw', () => { +describe('throwError', () => { asDiagram('throw(e)')('should create a cold observable that just emits an error', () => { const expected = '#'; - const e1 = Observable.throw('error'); + const e1 = throwError('error'); expectObservable(e1).toBe(expected); }); it('should emit one value', (done: MochaDone) => { let calls = 0; - Observable.throw('bad').subscribe(() => { + throwError('bad').subscribe(() => { done(new Error('should not be called')); }, (err: any) => { expect(++calls).to.equal(1); @@ -27,21 +26,8 @@ describe('Observable.throw', () => { }); }); - it('should create expose a error property', () => { - const e = Observable.throw('error'); - - expect(e['error']).to.equal('error'); - }); - - it('should create ErrorObservable via static create function', () => { - const e = new ErrorObservable('error'); - const r = ErrorObservable.create('error'); - - expect(e).to.deep.equal(r); - }); - it('should accept scheduler', () => { - const e = Observable.throw('error', rxTestScheduler); + const e = throwError('error', rxTestScheduler); expectObservable(e).toBe('#'); }); diff --git a/src/add/observable/throw.ts b/src/add/observable/throw.ts index af6674c667..20338e1a3e 100644 --- a/src/add/observable/throw.ts +++ b/src/add/observable/throw.ts @@ -1,4 +1,4 @@ import { Observable } from '../../internal/Observable'; -import { _throw } from '../../internal/observable/throw'; +import { throwError } from '../../internal/observable/throwError'; -Observable.throw = _throw; +(Observable as any).throw = throwError; diff --git a/src/create/index.ts b/src/create/index.ts index 0d9bc7b97f..c456b5a77d 100644 --- a/src/create/index.ts +++ b/src/create/index.ts @@ -19,7 +19,7 @@ export { onErrorResumeNext } from '../internal/observable/onErrorResumeNext'; export { pairs } from '../internal/observable/pairs'; export { race } from '../internal/observable/race'; export { range } from '../internal/observable/range'; -export { _throw as throwError } from '../internal/observable/throw'; +export { throwError } from '../internal/observable/throwError'; export { timer } from '../internal/observable/timer'; export { using } from '../internal/observable/using'; export { zip } from '../internal/observable/zip'; diff --git a/src/internal/Notification.ts b/src/internal/Notification.ts index ae8857243e..b7233cf759 100644 --- a/src/internal/Notification.ts +++ b/src/internal/Notification.ts @@ -2,7 +2,7 @@ import { PartialObserver } from './Observer'; import { Observable } from './Observable'; import { empty } from './observable/empty'; import { of } from './observable/of'; -import { _throw } from './observable/throw'; +import { throwError } from './observable/throwError'; /** * Represents a push-based event or value that an {@link Observable} can emit. @@ -89,7 +89,7 @@ export class Notification { case 'N': return of(this.value); case 'E': - return _throw(this.error); + return throwError(this.error); case 'C': return empty(); } diff --git a/src/internal/Observable.ts b/src/internal/Observable.ts index 16d2410bcb..cd77245ab9 100644 --- a/src/internal/Observable.ts +++ b/src/internal/Observable.ts @@ -5,7 +5,6 @@ import { Subscription, AnonymousSubscription, TeardownLogic } from './Subscripti import { root } from './util/root'; import { toSubscriber } from './util/toSubscriber'; import { IfObservable } from './observable/IfObservable'; -import { ErrorObservable } from './observable/ErrorObservable'; import { observable as Symbol_observable } from '../internal/symbol/observable'; import { OperatorFunction } from '../internal/types'; import { pipeFromArray } from './util/pipe'; @@ -256,7 +255,6 @@ export class Observable implements Subscribable { // `if` and `throw` are special snow flakes, the compiler sees them as reserved words static if: typeof IfObservable.create; - static throw: typeof ErrorObservable.create; /** * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable diff --git a/src/internal/observable/ErrorObservable.ts b/src/internal/observable/ErrorObservable.ts deleted file mode 100644 index 34eb9fb44d..0000000000 --- a/src/internal/observable/ErrorObservable.ts +++ /dev/null @@ -1,83 +0,0 @@ -import { IScheduler } from '../Scheduler'; -import { Observable } from '../Observable'; -import { TeardownLogic } from '../Subscription'; -import { Subscriber } from '../Subscriber'; - -export interface DispatchArg { - error: any; - subscriber: any; -} - -/** - * We need this JSDoc comment for affecting ESDoc. - * @extends {Ignored} - * @hide true - */ -export class ErrorObservable extends Observable { - - /** - * Creates an Observable that emits no items to the Observer and immediately - * emits an error notification. - * - * Just emits 'error', and nothing else. - * - * - * - * - * This static operator is useful for creating a simple Observable that only - * emits the error notification. It can be used for composing with other - * Observables, such as in a {@link mergeMap}. - * - * @example Emit the number 7, then emit an error. - * var result = Rx.Observable.throw(new Error('oops!')).startWith(7); - * result.subscribe(x => console.log(x), e => console.error(e)); - * - * @example Map and flatten numbers to the sequence 'a', 'b', 'c', but throw an error for 13 - * var interval = Rx.Observable.interval(1000); - * var result = interval.mergeMap(x => - * x === 13 ? - * Rx.Observable.throw('Thirteens are bad') : - * Rx.Observable.of('a', 'b', 'c') - * ); - * result.subscribe(x => console.log(x), e => console.error(e)); - * - * @see {@link create} - * @see {@link empty} - * @see {@link never} - * @see {@link of} - * - * @param {any} error The particular Error to pass to the error notification. - * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling - * the emission of the error notification. - * @return {Observable} An error Observable: emits only the error notification - * using the given error argument. - * @static true - * @name throw - * @owner Observable - */ - static create(error: any, scheduler?: IScheduler): ErrorObservable { - return new ErrorObservable(error, scheduler); - } - - static dispatch(arg: DispatchArg) { - const { error, subscriber } = arg; - subscriber.error(error); - } - - constructor(public error: any, private scheduler?: IScheduler) { - super(); - } - - protected _subscribe(subscriber: Subscriber): TeardownLogic { - const error = this.error; - const scheduler = this.scheduler; - - if (scheduler) { - return scheduler.schedule(ErrorObservable.dispatch, 0, { - error, subscriber - }); - } else { - subscriber.error(error); - } - } -} diff --git a/src/internal/observable/throw.ts b/src/internal/observable/throw.ts deleted file mode 100644 index 3e9ff96f8a..0000000000 --- a/src/internal/observable/throw.ts +++ /dev/null @@ -1,3 +0,0 @@ -import { ErrorObservable } from './ErrorObservable'; - -export const _throw = ErrorObservable.create; \ No newline at end of file diff --git a/src/internal/observable/throwError.ts b/src/internal/observable/throwError.ts new file mode 100644 index 0000000000..b16d17a026 --- /dev/null +++ b/src/internal/observable/throwError.ts @@ -0,0 +1,60 @@ +import { Observable } from '../Observable'; +import { IScheduler } from '../Scheduler'; +import { Subscriber } from '../Subscriber'; + +/** + * Creates an Observable that emits no items to the Observer and immediately + * emits an error notification. + * + * Just emits 'error', and nothing else. + * + * + * + * + * This static operator is useful for creating a simple Observable that only + * emits the error notification. It can be used for composing with other + * Observables, such as in a {@link mergeMap}. + * + * @example Emit the number 7, then emit an error. + * var result = Rx.Observable.throw(new Error('oops!')).startWith(7); + * result.subscribe(x => console.log(x), e => console.error(e)); + * + * @example Map and flatten numbers to the sequence 'a', 'b', 'c', but throw an error for 13 + * var interval = Rx.Observable.interval(1000); + * var result = interval.mergeMap(x => + * x === 13 ? + * Rx.Observable.throw('Thirteens are bad') : + * Rx.Observable.of('a', 'b', 'c') + * ); + * result.subscribe(x => console.log(x), e => console.error(e)); + * + * @see {@link create} + * @see {@link empty} + * @see {@link never} + * @see {@link of} + * + * @param {any} error The particular Error to pass to the error notification. + * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling + * the emission of the error notification. + * @return {Observable} An error Observable: emits only the error notification + * using the given error argument. + * @static true + * @name throw + * @owner Observable + */ +export function throwError(error: any, scheduler?: IScheduler): Observable { + if (!scheduler) { + return new Observable(subscriber => subscriber.error(error)); + } else { + return new Observable(subscriber => scheduler.schedule(dispatch, 0, { error, subscriber })); + } +} + +interface DispatchArg { + error: any; + subscriber: Subscriber; +} + +function dispatch({ error, subscriber }: DispatchArg) { + subscriber.error(error); +}