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

The Interactive Extensions for JavaScript

import { __asyncGenerator, __asyncValues, __await, __extends, __generator } from "tslib";
import { AsyncIterableX } from './../asynciterablex.js';
import { identityAsync } from '../../util/identity.js';
import { arrayIndexOfAsync } from '../../util/arrayindexof.js';
import { comparerAsync } from '../../util/comparer.js';
import { wrapWithAbort } from './withabort.js';
import { throwIfAborted } from '../../aborterror.js';
/** @ignore */
var DistinctAsyncIterable = /** @class */ (function (_super) {
    __extends(DistinctAsyncIterable, _super);
    function DistinctAsyncIterable(source, keySelector, comparer) {
        var _this = _super.call(this) || this;
        _this._source = source;
        _this._keySelector = keySelector;
        _this._comparer = comparer;
        return _this;
    }
    DistinctAsyncIterable.prototype[Symbol.asyncIterator] = function (signal) {
        return __asyncGenerator(this, arguments, function _a() {
            var set, _b, _c, _d, item, key, e_1_1;
            var _e, e_1, _f, _g;
            return __generator(this, function (_h) {
                switch (_h.label) {
                    case 0:
                        throwIfAborted(signal);
                        set = [];
                        _h.label = 1;
                    case 1:
                        _h.trys.push([1, 10, 11, 16]);
                        _b = true, _c = __asyncValues(wrapWithAbort(this._source, signal));
                        _h.label = 2;
                    case 2: return [4 /*yield*/, __await(_c.next())];
                    case 3:
                        if (!(_d = _h.sent(), _e = _d.done, !_e)) return [3 /*break*/, 9];
                        _g = _d.value;
                        _b = false;
                        item = _g;
                        return [4 /*yield*/, __await(this._keySelector(item, signal))];
                    case 4:
                        key = _h.sent();
                        return [4 /*yield*/, __await(arrayIndexOfAsync(set, key, this._comparer))];
                    case 5:
                        if (!((_h.sent()) === -1)) return [3 /*break*/, 8];
                        set.push(key);
                        return [4 /*yield*/, __await(item)];
                    case 6: return [4 /*yield*/, _h.sent()];
                    case 7:
                        _h.sent();
                        _h.label = 8;
                    case 8:
                        _b = true;
                        return [3 /*break*/, 2];
                    case 9: return [3 /*break*/, 16];
                    case 10:
                        e_1_1 = _h.sent();
                        e_1 = { error: e_1_1 };
                        return [3 /*break*/, 16];
                    case 11:
                        _h.trys.push([11, , 14, 15]);
                        if (!(!_b && !_e && (_f = _c.return))) return [3 /*break*/, 13];
                        return [4 /*yield*/, __await(_f.call(_c))];
                    case 12:
                        _h.sent();
                        _h.label = 13;
                    case 13: return [3 /*break*/, 15];
                    case 14:
                        if (e_1) throw e_1.error;
                        return [7 /*endfinally*/];
                    case 15: return [7 /*endfinally*/];
                    case 16: return [2 /*return*/];
                }
            });
        });
    };
    return DistinctAsyncIterable;
}(AsyncIterableX));
export { DistinctAsyncIterable };
/**
 * Returns an async-iterable sequence that contains only distinct elements according to the keySelector and comparer.
 *
 * @template TSource The type of the elements in the source sequence.
 * @template TKey The type of the discriminator key computed for each element in the source sequence.
 * @param {DistinctOptions<TSource, TKey = TSource>} [options] The optional arguments for a key selector and comparer function.
 * @returns {MonoTypeOperatorAsyncFunction<TSource>} An operator that returns distinct elements according to the keySelector and options.
 */
export function distinct(options) {
    return function distinctOperatorFunction(source) {
        var _a = options || {}, _b = _a["keySelector"], keySelector = _b === void 0 ? identityAsync : _b, _c = _a["comparer"], comparer = _c === void 0 ? comparerAsync : _c;
        return new DistinctAsyncIterable(source, keySelector, comparer);
    };
}

//# sourceMappingURL=distinct.js.map