@reactivex/ix-es5-esm/asynciterable/operators/tap.js

The Interactive Extensions for JavaScript

import { __asyncGenerator, __await, __extends, __generator } from "tslib";
import { AsyncIterableX } from '../asynciterablex.js';
import { toObserver } from '../../util/toobserver.js';
import { AbortError, throwIfAborted } from '../../aborterror.js';
import { returnAsyncIterator } from '../../util/returniterator.js';
/** @ignore */
var TapAsyncIterable = /** @class */ (function (_super) {
    __extends(TapAsyncIterable, _super);
    function TapAsyncIterable(source, observer) {
        var _this = _super.call(this) || this;
        _this._source = source;
        _this._observer = observer;
        return _this;
    }
    TapAsyncIterable.prototype[Symbol.asyncIterator] = function (signal) {
        return __asyncGenerator(this, arguments, function _a() {
            var obs, it, res, e_1;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        throwIfAborted(signal);
                        obs = this._observer;
                        it = this._source[Symbol.asyncIterator](signal);
                        _b.label = 1;
                    case 1:
                        _b.trys.push([1, 12, 15, 17]);
                        res = void 0;
                        _b.label = 2;
                    case 2: return [4 /*yield*/, __await(it.next())];
                    case 3:
                        if (!!(res = _b.sent()).done) return [3 /*break*/, 9];
                        if (!obs.next) return [3 /*break*/, 5];
                        return [4 /*yield*/, __await(obs.next(res.value))];
                    case 4:
                        _b.sent();
                        _b.label = 5;
                    case 5: return [4 /*yield*/, __await(res.value)];
                    case 6: return [4 /*yield*/, _b.sent()];
                    case 7:
                        _b.sent();
                        _b.label = 8;
                    case 8: return [3 /*break*/, 2];
                    case 9:
                        if (!obs.complete) return [3 /*break*/, 11];
                        return [4 /*yield*/, __await(obs.complete())];
                    case 10:
                        _b.sent();
                        _b.label = 11;
                    case 11: return [3 /*break*/, 17];
                    case 12:
                        e_1 = _b.sent();
                        if (!(!(e_1 instanceof AbortError) && obs.error)) return [3 /*break*/, 14];
                        return [4 /*yield*/, __await(obs.error(e_1))];
                    case 13:
                        _b.sent();
                        _b.label = 14;
                    case 14: throw e_1;
                    case 15: return [4 /*yield*/, __await(returnAsyncIterator(it))];
                    case 16:
                        _b.sent();
                        return [7 /*endfinally*/];
                    case 17: return [2 /*return*/];
                }
            });
        });
    };
    return TapAsyncIterable;
}(AsyncIterableX));
export { TapAsyncIterable };
/**
 * Invokes an action for each element in the async-iterable sequence, and propagates all observer
 * messages through the result sequence. This method can be used for debugging, logging, etc. by
 * intercepting the message stream to run arbitrary actions for messages on the pipeline.
 *
 * @template TSource The type of the elements in the source sequence.
 * @param {(PartialAsyncObserver<TSource> | ((value: TSource) => any) | null)} [observerOrNext] Observer whose methods to invoke as
 * part of the source sequence's observation or a function to invoke for each element in the async-iterable sequence.
 * @param {(((err: any) => any) | null)} [error] Function to invoke upon exceptional termination of the async-iterable sequence.
 * @param {((() => any) | null)} [complete] Function to invoke upon graceful termination of the async-iterable sequence.
 * @returns {MonoTypeOperatorAsyncFunction<TSource>} The source sequence with the side-effecting behavior applied.
 */
export function tap(observerOrNext, error, complete) {
    return function tapOperatorFunction(source) {
        return new TapAsyncIterable(source, toObserver(observerOrNext, error, complete));
    };
}

//# sourceMappingURL=tap.js.map