@reactivex/ix-es5-esm
Version:
The Interactive Extensions for JavaScript
123 lines (121 loc) • 5.51 kB
JavaScript
import { __asyncGenerator, __asyncValues, __await, __extends, __generator } from "tslib";
import { AsyncIterableX } from '../asynciterablex.js';
import { returnAsyncIterator } from '../../util/returniterator.js';
import { wrapWithAbort } from './withabort.js';
import { throwIfAborted } from '../../aborterror.js';
/** @ignore */
var CatchWithAsyncIterable = /** @class */ (function (_super) {
__extends(CatchWithAsyncIterable, _super);
function CatchWithAsyncIterable(source, handler) {
var _this = _super.call(this) || this;
_this._source = source;
_this._handler = handler;
return _this;
}
CatchWithAsyncIterable.prototype[Symbol.asyncIterator] = function (signal) {
return __asyncGenerator(this, arguments, function _a() {
var err, hasError, source, it, c, e_1, _b, _c, _d, item, e_2_1;
var _e, e_2, _f, _g;
return __generator(this, function (_h) {
switch (_h.label) {
case 0:
throwIfAborted(signal);
hasError = false;
source = wrapWithAbort(this._source, signal);
it = source[Symbol.asyncIterator]();
_h.label = 1;
case 1:
if (!1) return [3 /*break*/, 12];
c = {};
_h.label = 2;
case 2:
_h.trys.push([2, 6, , 9]);
return [4 /*yield*/, __await(it.next())];
case 3:
c = _h.sent();
if (!c.done) return [3 /*break*/, 5];
return [4 /*yield*/, __await(returnAsyncIterator(it))];
case 4:
_h.sent();
return [3 /*break*/, 12];
case 5: return [3 /*break*/, 9];
case 6:
e_1 = _h.sent();
return [4 /*yield*/, __await(this._handler(e_1, signal))];
case 7:
err = _h.sent();
hasError = true;
return [4 /*yield*/, __await(returnAsyncIterator(it))];
case 8:
_h.sent();
return [3 /*break*/, 12];
case 9: return [4 /*yield*/, __await(c.value)];
case 10: return [4 /*yield*/, _h.sent()];
case 11:
_h.sent();
return [3 /*break*/, 1];
case 12:
if (!hasError) return [3 /*break*/, 26];
_h.label = 13;
case 13:
_h.trys.push([13, 20, 21, 26]);
_b = true, _c = __asyncValues(wrapWithAbort(err, signal));
_h.label = 14;
case 14: return [4 /*yield*/, __await(_c.next())];
case 15:
if (!(_d = _h.sent(), _e = _d.done, !_e)) return [3 /*break*/, 19];
_g = _d.value;
_b = false;
item = _g;
return [4 /*yield*/, __await(item)];
case 16: return [4 /*yield*/, _h.sent()];
case 17:
_h.sent();
_h.label = 18;
case 18:
_b = true;
return [3 /*break*/, 14];
case 19: return [3 /*break*/, 26];
case 20:
e_2_1 = _h.sent();
e_2 = { error: e_2_1 };
return [3 /*break*/, 26];
case 21:
_h.trys.push([21, , 24, 25]);
if (!(!_b && !_e && (_f = _c.return))) return [3 /*break*/, 23];
return [4 /*yield*/, __await(_f.call(_c))];
case 22:
_h.sent();
_h.label = 23;
case 23: return [3 /*break*/, 25];
case 24:
if (e_2) throw e_2.error;
return [7 /*endfinally*/];
case 25: return [7 /*endfinally*/];
case 26: return [2 /*return*/];
}
});
});
};
return CatchWithAsyncIterable;
}(AsyncIterableX));
export { CatchWithAsyncIterable };
/**
* Continues an async-iterable sequence that is terminated by an exception with the
* async-iterable sequence produced by the handler.
*
* @template TSource The type of the elements in the source sequence.
* @template TResult The type of elements from the handler function.
* @param {((
* error: any,
* signal?: AbortSignal
* ) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>)} handler Error handler function, producing another async-iterable sequence.
* @returns {(OperatorAsyncFunction<TSource, TSource | TResult>)} An operator which continues an async-iterable sequence that is terminated by
* an exception with the specified handler.
*/
export function catchError(handler) {
return function catchWithOperatorFunction(source) {
return new CatchWithAsyncIterable(source, handler);
};
}
//# sourceMappingURL=catcherror.js.map