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

The Interactive Extensions for JavaScript

import { __asyncGenerator, __await, __extends, __generator, __read, __spreadArray } from "tslib";
import { AsyncIterableX } from '../asynciterablex.js';
import { wrapWithAbort } from './withabort.js';
import { throwIfAborted } from '../../aborterror.js';
import { identity } from '../../util/identity.js';
import { safeRace } from '../../util/safeRace.js';
// eslint-disable-next-line @typescript-eslint/no-empty-function
var NEVER_PROMISE = new Promise(function () { });
function wrapPromiseWithIndex(promise, index) {
    return promise.then(function (value) { return ({ value: value, index: index }); });
}
/** @ignore */
var WithLatestFromAsyncIterable = /** @class */ (function (_super) {
    __extends(WithLatestFromAsyncIterable, _super);
    function WithLatestFromAsyncIterable(source, others) {
        var _this = _super.call(this) || this;
        _this._source = source;
        _this._others = others;
        return _this;
    }
    WithLatestFromAsyncIterable.prototype[Symbol.asyncIterator] = function (signal) {
        return __asyncGenerator(this, arguments, function _a() {
            var length, newLength, iterators, nexts, hasValueAll, hasValue, values, i, iterator, it, next, _b, _c, value$, done$, index, iterator$, iterator$;
            return __generator(this, function (_d) {
                switch (_d.label) {
                    case 0:
                        throwIfAborted(signal);
                        length = this._others.length;
                        newLength = length + 1;
                        iterators = new Array(newLength);
                        nexts = new Array(newLength);
                        hasValueAll = false;
                        hasValue = new Array(length);
                        values = new Array(length);
                        hasValue.fill(false);
                        for (i = 0; i < length; i++) {
                            iterator = wrapWithAbort(this._others[i], signal)[Symbol.asyncIterator]();
                            iterators[i] = iterator;
                            nexts[i] = wrapPromiseWithIndex(iterator.next(), i);
                        }
                        it = wrapWithAbort(this._source, signal)[Symbol.asyncIterator]();
                        iterators[length] = it;
                        nexts[length] = wrapPromiseWithIndex(it.next(), length);
                        _d.label = 1;
                    case 1:
                        next = safeRace(nexts);
                        return [4 /*yield*/, __await(next)];
                    case 2:
                        _b = _d.sent(), _c = _b.value, value$ = _c.value, done$ = _c.done, index = _b.index;
                        if (!(index === length)) return [3 /*break*/, 6];
                        if (done$) {
                            return [3 /*break*/, 8];
                        }
                        iterator$ = iterators[index];
                        nexts[index] = wrapPromiseWithIndex(iterator$.next(), index);
                        if (!hasValueAll) return [3 /*break*/, 5];
                        return [4 /*yield*/, __await(__spreadArray([value$], __read(values), false))];
                    case 3: return [4 /*yield*/, _d.sent()];
                    case 4:
                        _d.sent();
                        _d.label = 5;
                    case 5: return [3 /*break*/, 7];
                    case 6:
                        if (done$) {
                            nexts[index] = NEVER_PROMISE;
                        }
                        else {
                            values[index] = value$;
                            hasValue[index] = true;
                            hasValueAll = hasValue.every(identity);
                            iterator$ = iterators[index];
                            nexts[index] = wrapPromiseWithIndex(iterator$.next(), index);
                        }
                        _d.label = 7;
                    case 7: return [3 /*break*/, 1];
                    case 8: return [2 /*return*/];
                }
            });
        });
    };
    return WithLatestFromAsyncIterable;
}(AsyncIterableX));
export { WithLatestFromAsyncIterable };
export function withLatestFrom() {
    var sources = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        sources[_i] = arguments[_i];
    }
    return function withLatestFromOperatorFunction(source) {
        return new WithLatestFromAsyncIterable(source, sources);
    };
}

//# sourceMappingURL=withlatestfrom.js.map