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

The Interactive Extensions for JavaScript

import { __asyncGenerator, __asyncValues, __await, __extends, __generator } from "tslib";
import { AsyncIterableX } from '../asynciterablex.js';
import { createGrouping } from './_grouping.js';
import { empty } from '../empty.js';
import { identity } from '../../util/identity.js';
import { wrapWithAbort } from './withabort.js';
import { throwIfAborted } from '../../aborterror.js';
/** @ignore */
var GroupJoinAsyncIterable = /** @class */ (function (_super) {
    __extends(GroupJoinAsyncIterable, _super);
    function GroupJoinAsyncIterable(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;
    }
    GroupJoinAsyncIterable.prototype[Symbol.asyncIterator] = function (signal) {
        return __asyncGenerator(this, arguments, function _a() {
            var map, _b, _c, _d, outerElement, outerKey, innerElements, e_1_1;
            var _e, e_1, _f, _g;
            return __generator(this, function (_h) {
                switch (_h.label) {
                    case 0:
                        throwIfAborted(signal);
                        return [4 /*yield*/, __await(createGrouping(this._inner, this._innerSelector, identity, signal))];
                    case 1:
                        map = _h.sent();
                        _h.label = 2;
                    case 2:
                        _h.trys.push([2, 11, 12, 17]);
                        _b = true, _c = __asyncValues(wrapWithAbort(this._outer, signal));
                        _h.label = 3;
                    case 3: return [4 /*yield*/, __await(_c.next())];
                    case 4:
                        if (!(_d = _h.sent(), _e = _d.done, !_e)) return [3 /*break*/, 10];
                        _g = _d.value;
                        _b = false;
                        outerElement = _g;
                        return [4 /*yield*/, __await(this._outerSelector(outerElement, signal))];
                    case 5:
                        outerKey = _h.sent();
                        innerElements = map.has(outerKey) ? map.get(outerKey) : empty();
                        return [4 /*yield*/, __await(this._resultSelector(outerElement, AsyncIterableX.as(innerElements), signal))];
                    case 6: return [4 /*yield*/, __await.apply(void 0, [_h.sent()])];
                    case 7: return [4 /*yield*/, _h.sent()];
                    case 8:
                        _h.sent();
                        _h.label = 9;
                    case 9:
                        _b = true;
                        return [3 /*break*/, 3];
                    case 10: return [3 /*break*/, 17];
                    case 11:
                        e_1_1 = _h.sent();
                        e_1 = { error: e_1_1 };
                        return [3 /*break*/, 17];
                    case 12:
                        _h.trys.push([12, , 15, 16]);
                        if (!(!_b && !_e && (_f = _c.return))) return [3 /*break*/, 14];
                        return [4 /*yield*/, __await(_f.call(_c))];
                    case 13:
                        _h.sent();
                        _h.label = 14;
                    case 14: return [3 /*break*/, 16];
                    case 15:
                        if (e_1) throw e_1.error;
                        return [7 /*endfinally*/];
                    case 16: return [7 /*endfinally*/];
                    case 17: return [2 /*return*/];
                }
            });
        });
    };
    return GroupJoinAsyncIterable;
}(AsyncIterableX));
export { GroupJoinAsyncIterable };
/**
 * Correlates the elements of two async-iterable sequences based on equality of keys and groups the results.
 *
 * @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: AsyncIterable<TInner>,
 *     signal?: AbortSignal
 *   ) => TResult | Promise<TResult>)} resultSelector A function to create a result element from an element from the first sequence and a
 * collection of matching elements from the second sequence.
 * @returns {OperatorAsyncFunction<TOuter, TResult>} An operator that returns an async-iterable sequence that contains the result elements
 * that are obtained by performing a grouped join on two sequences.
 */
export function groupJoin(inner, outerSelector, innerSelector, resultSelector) {
    return function groupJoinOperatorFunction(outer) {
        return new GroupJoinAsyncIterable(outer, inner, outerSelector, innerSelector, resultSelector);
    };
}

//# sourceMappingURL=groupjoin.js.map