| import { isFunction } from './util/isFunction'; |
| import { Subscription } from './Subscription'; |
| import { empty as emptyObserver } from './Observer'; |
| import { rxSubscriber as rxSubscriberSymbol } from './symbol/rxSubscriber'; |
| /** |
| * Implements the {@link Observer} interface and extends the |
| * {@link Subscription} class. While the {@link Observer} is the public API for |
| * consuming the values of an {@link Observable}, all Observers get converted to |
| * a Subscriber, in order to provide Subscription-like capabilities such as |
| * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for |
| * implementing operators, but it is rarely used as a public API. |
| * |
| * @class Subscriber<T> |
| */ |
| export class Subscriber extends Subscription { |
| /** |
| * @param {Observer|function(value: T): void} [destinationOrNext] A partially |
| * defined Observer or a `next` callback function. |
| * @param {function(e: ?any): void} [error] The `error` callback of an |
| * Observer. |
| * @param {function(): void} [complete] The `complete` callback of an |
| * Observer. |
| */ |
| constructor(destinationOrNext, error, complete) { |
| super(); |
| this.syncErrorValue = null; |
| this.syncErrorThrown = false; |
| this.syncErrorThrowable = false; |
| this.isStopped = false; |
| switch (arguments.length) { |
| case 0: |
| this.destination = emptyObserver; |
| break; |
| case 1: |
| if (!destinationOrNext) { |
| this.destination = emptyObserver; |
| break; |
| } |
| if (typeof destinationOrNext === 'object') { |
| if (destinationOrNext instanceof Subscriber) { |
| this.syncErrorThrowable = destinationOrNext.syncErrorThrowable; |
| this.destination = destinationOrNext; |
| this.destination.add(this); |
| } |
| else { |
| this.syncErrorThrowable = true; |
| this.destination = new SafeSubscriber(this, destinationOrNext); |
| } |
| break; |
| } |
| default: |
| this.syncErrorThrowable = true; |
| this.destination = new SafeSubscriber(this, destinationOrNext, error, complete); |
| break; |
| } |
| } |
| [rxSubscriberSymbol]() { return this; } |
| /** |
| * A static factory for a Subscriber, given a (potentially partial) definition |
| * of an Observer. |
| * @param {function(x: ?T): void} [next] The `next` callback of an Observer. |
| * @param {function(e: ?any): void} [error] The `error` callback of an |
| * Observer. |
| * @param {function(): void} [complete] The `complete` callback of an |
| * Observer. |
| * @return {Subscriber<T>} A Subscriber wrapping the (partially defined) |
| * Observer represented by the given arguments. |
| */ |
| static create(next, error, complete) { |
| const subscriber = new Subscriber(next, error, complete); |
| subscriber.syncErrorThrowable = false; |
| return subscriber; |
| } |
| /** |
| * The {@link Observer} callback to receive notifications of type `next` from |
| * the Observable, with a value. The Observable may call this method 0 or more |
| * times. |
| * @param {T} [value] The `next` value. |
| * @return {void} |
| */ |
| next(value) { |
| if (!this.isStopped) { |
| this._next(value); |
| } |
| } |
| /** |
| * The {@link Observer} callback to receive notifications of type `error` from |
| * the Observable, with an attached {@link Error}. Notifies the Observer that |
| * the Observable has experienced an error condition. |
| * @param {any} [err] The `error` exception. |
| * @return {void} |
| */ |
| error(err) { |
| if (!this.isStopped) { |
| this.isStopped = true; |
| this._error(err); |
| } |
| } |
| /** |
| * The {@link Observer} callback to receive a valueless notification of type |
| * `complete` from the Observable. Notifies the Observer that the Observable |
| * has finished sending push-based notifications. |
| * @return {void} |
| */ |
| complete() { |
| if (!this.isStopped) { |
| this.isStopped = true; |
| this._complete(); |
| } |
| } |
| unsubscribe() { |
| if (this.closed) { |
| return; |
| } |
| this.isStopped = true; |
| super.unsubscribe(); |
| } |
| _next(value) { |
| this.destination.next(value); |
| } |
| _error(err) { |
| this.destination.error(err); |
| this.unsubscribe(); |
| } |
| _complete() { |
| this.destination.complete(); |
| this.unsubscribe(); |
| } |
| _unsubscribeAndRecycle() { |
| const { _parent, _parents } = this; |
| this._parent = null; |
| this._parents = null; |
| this.unsubscribe(); |
| this.closed = false; |
| this.isStopped = false; |
| this._parent = _parent; |
| this._parents = _parents; |
| return this; |
| } |
| } |
| /** |
| * We need this JSDoc comment for affecting ESDoc. |
| * @ignore |
| * @extends {Ignored} |
| */ |
| class SafeSubscriber extends Subscriber { |
| constructor(_parentSubscriber, observerOrNext, error, complete) { |
| super(); |
| this._parentSubscriber = _parentSubscriber; |
| let next; |
| let context = this; |
| if (isFunction(observerOrNext)) { |
| next = observerOrNext; |
| } |
| else if (observerOrNext) { |
| next = observerOrNext.next; |
| error = observerOrNext.error; |
| complete = observerOrNext.complete; |
| if (observerOrNext !== emptyObserver) { |
| context = Object.create(observerOrNext); |
| if (isFunction(context.unsubscribe)) { |
| this.add(context.unsubscribe.bind(context)); |
| } |
| context.unsubscribe = this.unsubscribe.bind(this); |
| } |
| } |
| this._context = context; |
| this._next = next; |
| this._error = error; |
| this._complete = complete; |
| } |
| next(value) { |
| if (!this.isStopped && this._next) { |
| const { _parentSubscriber } = this; |
| if (!_parentSubscriber.syncErrorThrowable) { |
| this.__tryOrUnsub(this._next, value); |
| } |
| else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) { |
| this.unsubscribe(); |
| } |
| } |
| } |
| error(err) { |
| if (!this.isStopped) { |
| const { _parentSubscriber } = this; |
| if (this._error) { |
| if (!_parentSubscriber.syncErrorThrowable) { |
| this.__tryOrUnsub(this._error, err); |
| this.unsubscribe(); |
| } |
| else { |
| this.__tryOrSetError(_parentSubscriber, this._error, err); |
| this.unsubscribe(); |
| } |
| } |
| else if (!_parentSubscriber.syncErrorThrowable) { |
| this.unsubscribe(); |
| throw err; |
| } |
| else { |
| _parentSubscriber.syncErrorValue = err; |
| _parentSubscriber.syncErrorThrown = true; |
| this.unsubscribe(); |
| } |
| } |
| } |
| complete() { |
| if (!this.isStopped) { |
| const { _parentSubscriber } = this; |
| if (this._complete) { |
| const wrappedComplete = () => this._complete.call(this._context); |
| if (!_parentSubscriber.syncErrorThrowable) { |
| this.__tryOrUnsub(wrappedComplete); |
| this.unsubscribe(); |
| } |
| else { |
| this.__tryOrSetError(_parentSubscriber, wrappedComplete); |
| this.unsubscribe(); |
| } |
| } |
| else { |
| this.unsubscribe(); |
| } |
| } |
| } |
| __tryOrUnsub(fn, value) { |
| try { |
| fn.call(this._context, value); |
| } |
| catch (err) { |
| this.unsubscribe(); |
| throw err; |
| } |
| } |
| __tryOrSetError(parent, fn, value) { |
| try { |
| fn.call(this._context, value); |
| } |
| catch (err) { |
| parent.syncErrorValue = err; |
| parent.syncErrorThrown = true; |
| return true; |
| } |
| return false; |
| } |
| _unsubscribe() { |
| const { _parentSubscriber } = this; |
| this._context = null; |
| this._parentSubscriber = null; |
| _parentSubscriber.unsubscribe(); |
| } |
| } |
| //# sourceMappingURL=Subscriber.js.map |