118 lines
4.0 KiB
JavaScript
118 lines
4.0 KiB
JavaScript
|
/** PURE_IMPORTS_START .._OuterSubscriber,.._util_subscribeToResult PURE_IMPORTS_END */
|
||
|
|
var __extends = (this && this.__extends) || function (d, b) {
|
||
|
|
for (var p in b)
|
||
|
|
if (b.hasOwnProperty(p))
|
||
|
|
d[p] = b[p];
|
||
|
|
function __() { this.constructor = d; }
|
||
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||
|
|
};
|
||
|
|
import { OuterSubscriber } from '../OuterSubscriber';
|
||
|
|
import { subscribeToResult } from '../util/subscribeToResult';
|
||
|
|
/**
|
||
|
|
* Catches errors on the observable to be handled by returning a new observable or throwing an error.
|
||
|
|
*
|
||
|
|
* <img src="./img/catch.png" width="100%">
|
||
|
|
*
|
||
|
|
* @example <caption>Continues with a different Observable when there's an error</caption>
|
||
|
|
*
|
||
|
|
* Observable.of(1, 2, 3, 4, 5)
|
||
|
|
* .map(n => {
|
||
|
|
* if (n == 4) {
|
||
|
|
* throw 'four!';
|
||
|
|
* }
|
||
|
|
* return n;
|
||
|
|
* })
|
||
|
|
* .catch(err => Observable.of('I', 'II', 'III', 'IV', 'V'))
|
||
|
|
* .subscribe(x => console.log(x));
|
||
|
|
* // 1, 2, 3, I, II, III, IV, V
|
||
|
|
*
|
||
|
|
* @example <caption>Retries the caught source Observable again in case of error, similar to retry() operator</caption>
|
||
|
|
*
|
||
|
|
* Observable.of(1, 2, 3, 4, 5)
|
||
|
|
* .map(n => {
|
||
|
|
* if (n === 4) {
|
||
|
|
* throw 'four!';
|
||
|
|
* }
|
||
|
|
* return n;
|
||
|
|
* })
|
||
|
|
* .catch((err, caught) => caught)
|
||
|
|
* .take(30)
|
||
|
|
* .subscribe(x => console.log(x));
|
||
|
|
* // 1, 2, 3, 1, 2, 3, ...
|
||
|
|
*
|
||
|
|
* @example <caption>Throws a new error when the source Observable throws an error</caption>
|
||
|
|
*
|
||
|
|
* Observable.of(1, 2, 3, 4, 5)
|
||
|
|
* .map(n => {
|
||
|
|
* if (n == 4) {
|
||
|
|
* throw 'four!';
|
||
|
|
* }
|
||
|
|
* return n;
|
||
|
|
* })
|
||
|
|
* .catch(err => {
|
||
|
|
* throw 'error in source. Details: ' + err;
|
||
|
|
* })
|
||
|
|
* .subscribe(
|
||
|
|
* x => console.log(x),
|
||
|
|
* err => console.log(err)
|
||
|
|
* );
|
||
|
|
* // 1, 2, 3, error in source. Details: four!
|
||
|
|
*
|
||
|
|
* @param {function} selector a function that takes as arguments `err`, which is the error, and `caught`, which
|
||
|
|
* is the source observable, in case you'd like to "retry" that observable by returning it again. Whatever observable
|
||
|
|
* is returned by the `selector` will be used to continue the observable chain.
|
||
|
|
* @return {Observable} An observable that originates from either the source or the observable returned by the
|
||
|
|
* catch `selector` function.
|
||
|
|
* @name catchError
|
||
|
|
*/
|
||
|
|
export function catchError(selector) {
|
||
|
|
return function catchErrorOperatorFunction(source) {
|
||
|
|
var operator = new CatchOperator(selector);
|
||
|
|
var caught = source.lift(operator);
|
||
|
|
return (operator.caught = caught);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
var CatchOperator = /*@__PURE__*/ (/*@__PURE__*/ function () {
|
||
|
|
function CatchOperator(selector) {
|
||
|
|
this.selector = selector;
|
||
|
|
}
|
||
|
|
CatchOperator.prototype.call = function (subscriber, source) {
|
||
|
|
return source.subscribe(new CatchSubscriber(subscriber, this.selector, this.caught));
|
||
|
|
};
|
||
|
|
return CatchOperator;
|
||
|
|
}());
|
||
|
|
/**
|
||
|
|
* We need this JSDoc comment for affecting ESDoc.
|
||
|
|
* @ignore
|
||
|
|
* @extends {Ignored}
|
||
|
|
*/
|
||
|
|
var CatchSubscriber = /*@__PURE__*/ (/*@__PURE__*/ function (_super) {
|
||
|
|
__extends(CatchSubscriber, _super);
|
||
|
|
function CatchSubscriber(destination, selector, caught) {
|
||
|
|
_super.call(this, destination);
|
||
|
|
this.selector = selector;
|
||
|
|
this.caught = caught;
|
||
|
|
}
|
||
|
|
// NOTE: overriding `error` instead of `_error` because we don't want
|
||
|
|
// to have this flag this subscriber as `isStopped`. We can mimic the
|
||
|
|
// behavior of the RetrySubscriber (from the `retry` operator), where
|
||
|
|
// we unsubscribe from our source chain, reset our Subscriber flags,
|
||
|
|
// then subscribe to the selector result.
|
||
|
|
CatchSubscriber.prototype.error = function (err) {
|
||
|
|
if (!this.isStopped) {
|
||
|
|
var result = void 0;
|
||
|
|
try {
|
||
|
|
result = this.selector(err, this.caught);
|
||
|
|
}
|
||
|
|
catch (err2) {
|
||
|
|
_super.prototype.error.call(this, err2);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
this._unsubscribeAndRecycle();
|
||
|
|
this.add(subscribeToResult(this, result));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return CatchSubscriber;
|
||
|
|
}(OuterSubscriber));
|
||
|
|
//# sourceMappingURL=catchError.js.map
|