@reactivex/ix-es5-esm
Version:
The Interactive Extensions for JavaScript
126 lines (124 loc) • 6.22 kB
JavaScript
import { __asyncGenerator, __asyncValues, __await, __extends, __generator, __values } from "tslib";
import { AsyncIterableX } from '../asynciterablex.js';
import { createGrouping } from './_grouping.js';
import { identity } from '../../util/identity.js';
import { wrapWithAbort } from './withabort.js';
import { throwIfAborted } from '../../aborterror.js';
/** @ignore */
var JoinAsyncIterable = /** @class */ (function (_super) {
__extends(JoinAsyncIterable, _super);
function JoinAsyncIterable(outer, inner, outerSelector, innerSelector, resultSelector) {
var _this = _super.call(this) || this;
_this._outer = outer;
_this._inner = inner;
_this._outerSelector = outerSelector;
_this._innerSelector = innerSelector;
_this._resultSelector = resultSelector;
return _this;
}
JoinAsyncIterable.prototype[Symbol.asyncIterator] = function (signal) {
return __asyncGenerator(this, arguments, function _a() {
var map, _b, _c, _d, outerElement, outerKey, _e, _f, innerElement, e_1_1, e_2_1;
var e_1, _g;
var _h, e_2, _j, _k;
return __generator(this, function (_l) {
switch (_l.label) {
case 0:
throwIfAborted(signal);
return [4 /*yield*/, __await(createGrouping(this._inner, this._innerSelector, identity, signal))];
case 1:
map = _l.sent();
_l.label = 2;
case 2:
_l.trys.push([2, 17, 18, 23]);
_b = true, _c = __asyncValues(wrapWithAbort(this._outer, signal));
_l.label = 3;
case 3: return [4 /*yield*/, __await(_c.next())];
case 4:
if (!(_d = _l.sent(), _h = _d.done, !_h)) return [3 /*break*/, 16];
_k = _d.value;
_b = false;
outerElement = _k;
return [4 /*yield*/, __await(this._outerSelector(outerElement, signal))];
case 5:
outerKey = _l.sent();
if (!map.has(outerKey)) return [3 /*break*/, 15];
_l.label = 6;
case 6:
_l.trys.push([6, 13, 14, 15]);
_e = (e_1 = void 0, __values(map.get(outerKey))), _f = _e.next();
_l.label = 7;
case 7:
if (!!_f.done) return [3 /*break*/, 12];
innerElement = _f.value;
return [4 /*yield*/, __await(this._resultSelector(outerElement, innerElement, signal))];
case 8: return [4 /*yield*/, __await.apply(void 0, [_l.sent()])];
case 9: return [4 /*yield*/, _l.sent()];
case 10:
_l.sent();
_l.label = 11;
case 11:
_f = _e.next();
return [3 /*break*/, 7];
case 12: return [3 /*break*/, 15];
case 13:
e_1_1 = _l.sent();
e_1 = { error: e_1_1 };
return [3 /*break*/, 15];
case 14:
try {
if (_f && !_f.done && (_g = _e.return)) _g.call(_e);
}
finally { if (e_1) throw e_1.error; }
return [7 /*endfinally*/];
case 15:
_b = true;
return [3 /*break*/, 3];
case 16: return [3 /*break*/, 23];
case 17:
e_2_1 = _l.sent();
e_2 = { error: e_2_1 };
return [3 /*break*/, 23];
case 18:
_l.trys.push([18, , 21, 22]);
if (!(!_b && !_h && (_j = _c.return))) return [3 /*break*/, 20];
return [4 /*yield*/, __await(_j.call(_c))];
case 19:
_l.sent();
_l.label = 20;
case 20: return [3 /*break*/, 22];
case 21:
if (e_2) throw e_2.error;
return [7 /*endfinally*/];
case 22: return [7 /*endfinally*/];
case 23: return [2 /*return*/];
}
});
});
};
return JoinAsyncIterable;
}(AsyncIterableX));
export { JoinAsyncIterable };
/**
* Correlates the elements of two sequences based on matching keys.
*
* @template TOuter The type of the elements of the first async-iterable sequence.
* @template TInner The type of the elements of the second async-iterable sequence.
* @template TKey The type of the keys returned by the key selector functions.
* @template TResult The type of the result elements.
* @param {AsyncIterable<TInner>} inner The async-enumerable sequence to join to the first sequence.
* @param {((value: TOuter, signal?: AbortSignal) => TKey | Promise<TKey>)} outerSelector A function to extract the join key from each element
* of the first sequence.
* @param {((value: TInner, signal?: AbortSignal) => TKey | Promise<TKey>)} innerSelector A function to extract the join key from each element
* of the second sequence.
* @param {((outer: TOuter, inner: TInner, signal?: AbortSignal) => TResult | Promise<TResult>)} resultSelector A function to create a result element
* from two matching elements.
* @returns {OperatorAsyncFunction<TOuter, TResult>} An async-iterable sequence that has elements that are obtained by performing an inner join
* on two sequences.
*/
export function innerJoin(inner, outerSelector, innerSelector, resultSelector) {
return function innerJoinOperatorFunction(outer) {
return new JoinAsyncIterable(outer, inner, outerSelector, innerSelector, resultSelector);
};
}
//# sourceMappingURL=innerjoin.js.map