@reactivex/ix-es5-esm
Version:
The Interactive Extensions for JavaScript
200 lines (198 loc) • 9.95 kB
JavaScript
import { __asyncGenerator, __asyncValues, __await, __extends, __generator, __read, __spreadArray } from "tslib";
import { AsyncIterableX } from '../asynciterablex.js';
import { wrapWithAbort } from '../operators/withabort.js';
import { AbortError, throwIfAborted } from '../../aborterror.js';
import { safeRace } from '../../util/safeRace.js';
import { isPromise } from '../../util/isiterable.js';
import { returnAsyncIterator } from '../../util/returniterator.js';
var NEVER_PROMISE = new Promise(function () { });
function ignoreInnerAbortErrors(signal) {
return function ignoreInnerAbortError(e) {
if (signal.aborted && e instanceof AbortError) {
return NEVER_PROMISE;
}
throw e;
};
}
function wrapIterator(source, index, type, signal) {
return __asyncGenerator(this, arguments, function wrapIterator_1() {
var _a, _b, _c, value, e_1_1;
var _d, e_1, _e, _f;
return __generator(this, function (_g) {
switch (_g.label) {
case 0:
throwIfAborted(signal);
_g.label = 1;
case 1:
_g.trys.push([1, 8, 9, 14]);
_a = true, _b = __asyncValues(wrapWithAbort(source, signal));
_g.label = 2;
case 2: return [4 /*yield*/, __await(_b.next())];
case 3:
if (!(_c = _g.sent(), _d = _c.done, !_d)) return [3 /*break*/, 7];
_f = _c.value;
_a = false;
value = _f;
throwIfAborted(signal);
return [4 /*yield*/, __await({ type: type, index: index, value: value })];
case 4: return [4 /*yield*/, _g.sent()];
case 5:
_g.sent();
_g.label = 6;
case 6:
_a = true;
return [3 /*break*/, 2];
case 7: return [3 /*break*/, 14];
case 8:
e_1_1 = _g.sent();
e_1 = { error: e_1_1 };
return [3 /*break*/, 14];
case 9:
_g.trys.push([9, , 12, 13]);
if (!(!_a && !_d && (_e = _b.return))) return [3 /*break*/, 11];
return [4 /*yield*/, __await(_e.call(_b))];
case 10:
_g.sent();
_g.label = 11;
case 11: return [3 /*break*/, 13];
case 12:
if (e_1) throw e_1.error;
return [7 /*endfinally*/];
case 13: return [7 /*endfinally*/];
case 14: return [4 /*yield*/, __await({ type: type, index: index, value: undefined })];
case 15: return [2 /*return*/, _g.sent()];
}
});
});
}
/** @ignore */
var FlattenConcurrentAsyncIterable = /** @class */ (function (_super) {
__extends(FlattenConcurrentAsyncIterable, _super);
function FlattenConcurrentAsyncIterable(_source, _selector, _concurrent, _switchMode, _thisArg) {
var _this = _super.call(this) || this;
_this._source = _source;
_this._selector = _selector;
_this._concurrent = _concurrent;
_this._switchMode = _switchMode;
_this._thisArg = _thisArg;
_this._concurrent = _this._switchMode ? 1 : Math.max(_concurrent, 1);
return _this;
}
FlattenConcurrentAsyncIterable.prototype[Symbol.asyncIterator] = function (outerSignal) {
return __asyncGenerator(this, arguments, function _a() {
function pullNextOuter(outerValue) {
++active;
var index = innerIndices.pop() || active;
// abort the current inner iterator first
if (switchMode && controllers[index - 1]) {
controllers[index - 1].abort();
}
controllers[index - 1] = new AbortController();
var innerSignal = controllers[index - 1].signal;
// Get the next inner sequence.
// `selector` is a sync or async function that returns AsyncIterableInput.
var inner = selector.call(thisArg, outerValue, outerIndex++, innerSignal);
results[index] = wrapAndPullInner(index, innerSignal, inner).catch(ignoreInnerAbortErrors(innerSignal));
}
function wrapAndPullInner(index, signal, inner) {
if (isPromise(inner)) {
return inner.then(function (inner) { return wrapAndPullInner(index, signal, inner); });
}
return (inners[index - 1] = wrapIterator(AsyncIterableX.as(inner), index, 1 /* Type.INNER */, signal)).next();
}
var active, outerIndex, outerComplete, thisArg, selector, switchMode, concurrent, outerValues, innerIndices, controllers, inners, outer, results, _b, _c, done, _d, type, value, index, _e, _f, _g, inner, _h, _j, signal;
return __generator(this, function (_k) {
switch (_k.label) {
case 0:
throwIfAborted(outerSignal);
active = 0;
outerIndex = 0;
outerComplete = false;
thisArg = this._thisArg;
selector = this._selector;
switchMode = this._switchMode;
concurrent = this._concurrent;
outerValues = new Array(0);
innerIndices = new Array(0);
controllers = new Array(isFinite(concurrent) ? concurrent : 0);
inners = new Array(isFinite(concurrent) ? concurrent : 0);
outer = wrapIterator(this._source, 0, 0 /* Type.OUTER */, outerSignal);
results = [outer.next()];
_k.label = 1;
case 1:
_k.trys.push([1, , 12, 14]);
_k.label = 2;
case 2: return [4 /*yield*/, __await(safeRace(results))];
case 3:
_b = _k.sent(), _c = _b.done, done = _c === void 0 ? false : _c, _d = _b.value, type = _d.type, value = _d.value, index = _d.index;
if (!!done) return [3 /*break*/, 9];
_e = type;
switch (_e) {
case 0 /* Type.OUTER */: return [3 /*break*/, 4];
case 1 /* Type.INNER */: return [3 /*break*/, 5];
}
return [3 /*break*/, 8];
case 4:
{
if (switchMode) {
active = 0;
}
if (active < concurrent) {
pullNextOuter(value);
}
else {
outerValues.push(value);
}
results[0] = outer.next();
return [3 /*break*/, 8];
}
_k.label = 5;
case 5: return [4 /*yield*/, __await(value)];
case 6: return [4 /*yield*/, _k.sent()];
case 7:
_k.sent();
_f = inners, _g = index - 1, inner = _f[_g];
_h = controllers, _j = index - 1, signal = _h[_j].signal;
results[index] = inner.next().catch(ignoreInnerAbortErrors(signal));
return [3 /*break*/, 8];
case 8: return [3 /*break*/, 10];
case 9:
// ignore this result slot
results[index] = NEVER_PROMISE;
switch (type) {
case 0 /* Type.OUTER */: {
outerComplete = true;
break;
}
case 1 /* Type.INNER */: {
--active;
// return the current slot to the pool
innerIndices.push(index);
// synchronously drain the `outerValues` buffer
while (active < concurrent && outerValues.length) {
// Don't use `await` so we avoid blocking while the number of active inner sequences is less than `concurrent`.
pullNextOuter(outerValues.shift());
}
break;
}
}
_k.label = 10;
case 10:
if (!outerComplete || active + outerValues.length > 0) return [3 /*break*/, 2];
_k.label = 11;
case 11: return [3 /*break*/, 14];
case 12:
controllers.forEach(function (controller) { return controller === null || controller === void 0 ? void 0 : controller.abort(); });
return [4 /*yield*/, __await(Promise.all(__spreadArray([outer], __read(inners), false).map(returnAsyncIterator)))];
case 13:
_k.sent();
return [7 /*endfinally*/];
case 14: return [2 /*return*/];
}
});
});
};
return FlattenConcurrentAsyncIterable;
}(AsyncIterableX));
export { FlattenConcurrentAsyncIterable };
//# sourceMappingURL=_flatten.js.map