@reactivex/ix-es5-esm
Version:
The Interactive Extensions for JavaScript
132 lines (130 loc) • 6.24 kB
JavaScript
import { __asyncGenerator, __asyncValues, __await, __extends, __generator } from "tslib";
import { AsyncIterableX } from '../asynciterablex.js';
import { wrapWithAbort } from './withabort.js';
import { throwIfAborted } from '../../aborterror.js';
import { isPromise } from '../../util/isiterable.js';
var ConcatMapAsyncIterable = /** @class */ (function (_super) {
__extends(ConcatMapAsyncIterable, _super);
function ConcatMapAsyncIterable(_source, _selector, _thisArg) {
var _this = _super.call(this) || this;
_this._source = _source;
_this._selector = _selector;
_this._thisArg = _thisArg;
return _this;
}
ConcatMapAsyncIterable.prototype[Symbol.asyncIterator] = function (signal) {
return __asyncGenerator(this, arguments, function _a() {
var outerIndex, _b, thisArg, selector, _c, _d, _e, outer, result, values, _f, _g, _h, _j, inner, e_1_1, e_2_1;
var _k, e_2, _l, _m, _o, e_1, _p, _q;
return __generator(this, function (_r) {
switch (_r.label) {
case 0:
throwIfAborted(signal);
outerIndex = 0;
_b = this, thisArg = _b._thisArg, selector = _b._selector;
_r.label = 1;
case 1:
_r.trys.push([1, 22, 23, 28]);
_c = true, _d = __asyncValues(wrapWithAbort(this._source, signal));
_r.label = 2;
case 2: return [4 /*yield*/, __await(_d.next())];
case 3:
if (!(_e = _r.sent(), _k = _e.done, !_k)) return [3 /*break*/, 21];
_m = _e.value;
_c = false;
outer = _m;
result = selector.call(thisArg, outer, outerIndex++, signal);
if (!isPromise(result)) return [3 /*break*/, 5];
return [4 /*yield*/, __await(result)];
case 4:
_f = _r.sent();
return [3 /*break*/, 6];
case 5:
_f = result;
_r.label = 6;
case 6:
values = (_f);
_r.label = 7;
case 7:
_r.trys.push([7, 14, 15, 20]);
_g = true, _h = (e_1 = void 0, __asyncValues(wrapWithAbort(AsyncIterableX.as(values), signal)));
_r.label = 8;
case 8: return [4 /*yield*/, __await(_h.next())];
case 9:
if (!(_j = _r.sent(), _o = _j.done, !_o)) return [3 /*break*/, 13];
_q = _j.value;
_g = false;
inner = _q;
return [4 /*yield*/, __await(inner)];
case 10: return [4 /*yield*/, _r.sent()];
case 11:
_r.sent();
_r.label = 12;
case 12:
_g = true;
return [3 /*break*/, 8];
case 13: return [3 /*break*/, 20];
case 14:
e_1_1 = _r.sent();
e_1 = { error: e_1_1 };
return [3 /*break*/, 20];
case 15:
_r.trys.push([15, , 18, 19]);
if (!(!_g && !_o && (_p = _h.return))) return [3 /*break*/, 17];
return [4 /*yield*/, __await(_p.call(_h))];
case 16:
_r.sent();
_r.label = 17;
case 17: return [3 /*break*/, 19];
case 18:
if (e_1) throw e_1.error;
return [7 /*endfinally*/];
case 19: return [7 /*endfinally*/];
case 20:
_c = true;
return [3 /*break*/, 2];
case 21: return [3 /*break*/, 28];
case 22:
e_2_1 = _r.sent();
e_2 = { error: e_2_1 };
return [3 /*break*/, 28];
case 23:
_r.trys.push([23, , 26, 27]);
if (!(!_c && !_k && (_l = _d.return))) return [3 /*break*/, 25];
return [4 /*yield*/, __await(_l.call(_d))];
case 24:
_r.sent();
_r.label = 25;
case 25: return [3 /*break*/, 27];
case 26:
if (e_2) throw e_2.error;
return [7 /*endfinally*/];
case 27: return [7 /*endfinally*/];
case 28: return [2 /*return*/];
}
});
});
};
return ConcatMapAsyncIterable;
}(AsyncIterableX));
/**
* Projects each element of an async-iterable sequence to an async-iterable sequence and merges
* the resulting async-iterable sequences into one async-iterable sequence.
*
* @template TSource The type of the elements in the source sequence.
* @template TResult The type of the elements in the projected inner sequences and the elements in the merged result sequence.
* @param {((
* value: TSource,
* index: number,
* signal?: AbortSignal
* ) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>)} selector A transform function to apply to each element.
* @param {*} [thisArg] Option this for binding to the selector.
* @returns {OperatorAsyncFunction<TSource, TResult>} An operator that creates an async-iterable sequence whose
* elements are the result of invoking the one-to-many transform function on each element of the input sequence.
*/
export function concatMap(selector, thisArg) {
return function concatMapOperatorFunction(source) {
return new ConcatMapAsyncIterable(source, selector, thisArg);
};
}
//# sourceMappingURL=concatmap.js.map