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

The Interactive Extensions for JavaScript

import { __asyncGenerator, __await, __awaiter, __extends, __generator } from "tslib";
import { AsyncIterableX } from '../asynciterablex.js';
import { AbortError, throwIfAborted } from '../../aborterror.js';
/** @ignore */
var DebounceAsyncIterable = /** @class */ (function (_super) {
    __extends(DebounceAsyncIterable, _super);
    function DebounceAsyncIterable(source, time) {
        var _this = _super.call(this) || this;
        _this._source = source;
        _this._time = time;
        return _this;
    }
    DebounceAsyncIterable.prototype[Symbol.asyncIterator] = function (signal) {
        return __asyncGenerator(this, arguments, function _a() {
            var done, reject, resolve, promise;
            var _this = this;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        throwIfAborted(signal);
                        done = false;
                        reject = function () {
                            /**/
                        };
                        resolve = function () {
                            /**/
                        };
                        promise = new Promise(function (r1, r2) {
                            resolve = r1;
                            reject = r2;
                        });
                        (function () { return __awaiter(_this, void 0, void 0, function () {
                            var id, emitValue, result, it_1, _b, e_1;
                            return __generator(this, function (_c) {
                                switch (_c.label) {
                                    case 0:
                                        id = null;
                                        emitValue = function (value) {
                                            id = null;
                                            resolve(value);
                                            promise = new Promise(function (r1, r2) {
                                                resolve = r1;
                                                reject = r2;
                                            });
                                        };
                                        if (signal) {
                                            signal.addEventListener('abort', function () {
                                                done = true;
                                                if (id) {
                                                    clearTimeout(id);
                                                }
                                                id = null;
                                                reject(new AbortError());
                                            }, { once: true });
                                        }
                                        _c.label = 1;
                                    case 1:
                                        _c.trys.push([1, 6, , 7]);
                                        result = void 0;
                                        it_1 = this._source[Symbol.asyncIterator](signal);
                                        _c.label = 2;
                                    case 2:
                                        _b = !done;
                                        if (!_b) return [3 /*break*/, 4];
                                        return [4 /*yield*/, it_1.next()];
                                    case 3:
                                        _b = !(result = _c.sent()).done;
                                        _c.label = 4;
                                    case 4:
                                        if (!(_b && !done)) return [3 /*break*/, 5];
                                        if (id) {
                                            clearTimeout(id);
                                        }
                                        id = setTimeout(emitValue, this._time, result.value);
                                        return [3 /*break*/, 2];
                                    case 5: return [3 /*break*/, 7];
                                    case 6:
                                        e_1 = _c.sent();
                                        reject(e_1);
                                        return [3 /*break*/, 7];
                                    case 7:
                                        done = true;
                                        return [2 /*return*/];
                                }
                            });
                        }); })();
                        _b.label = 1;
                    case 1:
                        if (!!done) return [3 /*break*/, 5];
                        return [4 /*yield*/, __await(promise)];
                    case 2: return [4 /*yield*/, __await.apply(void 0, [_b.sent()])];
                    case 3: return [4 /*yield*/, _b.sent()];
                    case 4:
                        _b.sent();
                        return [3 /*break*/, 1];
                    case 5: return [2 /*return*/];
                }
            });
        });
    };
    return DebounceAsyncIterable;
}(AsyncIterableX));
export { DebounceAsyncIterable };
/**
 * Emits a notification from the source async-iterable only after a particular time span
 * has passed without another source emission.
 *
 * @template TSource The type of elements in the source sequence.
 * @param {number} time The timeout duration in milliseconds
 * @returns {MonoTypeOperatorAsyncFunction<TSource>} An operator function which debounces by the given timeout.
 */
export function debounce(time) {
    return function debounceOperatorFunction(source) {
        return new DebounceAsyncIterable(source, time);
    };
}

//# sourceMappingURL=debounce.js.map