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

The Interactive Extensions for JavaScript

import { __extends } from "tslib";
import { AsyncIterableX } from '../asynciterablex.js';
import { wrapWithAbort } from './withabort.js';
import { throwIfAborted } from '../../aborterror.js';
var WAITING_TYPE = 'waiting';
var BATCHING_TYPE = 'batching';
function assertNever(value) {
    throw new Error("Unhandled discriminated union member ".concat(value));
}
/** @ignore */
var BatchAsyncIterable = /** @class */ (function (_super) {
    __extends(BatchAsyncIterable, _super);
    function BatchAsyncIterable(source) {
        var _this = _super.call(this) || this;
        _this._source = source;
        return _this;
    }
    BatchAsyncIterable.prototype[Symbol.asyncIterator] = function (signal) {
        throwIfAborted(signal);
        var it = wrapWithAbort(this._source, signal)[Symbol.asyncIterator]();
        var state = { type: BATCHING_TYPE, values: [] };
        var ended = null;
        var error = null;
        function consumeNext() {
            it.next().then(function (res) {
                if (res.done) {
                    ended = Promise.resolve({ done: true });
                    if (state.type === WAITING_TYPE) {
                        state.resolver.resolve(ended);
                    }
                }
                else {
                    if (state.type === WAITING_TYPE) {
                        var resolve = state.resolver.resolve;
                        state = { type: BATCHING_TYPE, values: [] };
                        resolve({ done: res.done, value: [res.value] });
                    }
                    else if (state.type === BATCHING_TYPE) {
                        state.values.push(res.value);
                    }
                    else {
                        assertNever(state);
                    }
                    consumeNext();
                }
            }, function (err) {
                error = err;
                if (state.type === WAITING_TYPE) {
                    state.resolver.reject(err);
                }
            });
        }
        consumeNext();
        return {
            next: function () {
                if (error) {
                    return Promise.reject(error);
                }
                if (state.type === BATCHING_TYPE && state.values.length > 0) {
                    var values = state.values;
                    state.values = [];
                    return Promise.resolve({ done: false, value: values });
                }
                if (ended) {
                    return ended;
                }
                if (state.type === WAITING_TYPE) {
                    throw new Error('Previous `next()` is still in progress');
                }
                return new Promise(function (resolve, reject) {
                    state = {
                        type: WAITING_TYPE,
                        resolver: { resolve: resolve, reject: reject },
                    };
                });
            },
            return: function (value) {
                return it.return
                    ? it.return(value).then(function () { return ({ done: true }); })
                    : Promise.resolve({ done: true });
            },
        };
    };
    return BatchAsyncIterable;
}(AsyncIterableX));
export { BatchAsyncIterable };
/**
Returns an async iterable sequence of batches that are collected from the source sequence between
 * subsequent `next()` calls.
 *
 * @template TSource The type of elements in the source sequence.
 * @returns {OperatorAsyncFunction<TSource, TSource[]>} An operator returning an async-iterable of batches that are collection from the
 * source sequence between subsequent `next()` calls.
 */
export function batch() {
    return function batchOperator(source) {
        return new BatchAsyncIterable(source);
    };
}

//# sourceMappingURL=batch.js.map