@reactivex/ix-esnext-esm/asynciterable/memoize.js

import { AsyncIterableX } from './asynciterablex';
import { MaxRefCountList, RefCountList } from '../iterable/_refcountlist';
import { create } from './create';
export class MemoizeAsyncBuffer extends AsyncIterableX {
    constructor(source, buffer) {
        super();
        this._stopped = false;
        this._source = source;
        this._buffer = buffer;
    }
    async *[Symbol.asyncIterator]() {
        let i = 0;
        try {
            while (1) {
                let hasValue = false, current = {};
                if (i >= this._buffer.count) {
                    if (!this._stopped) {
                        try {
                            let next = await this._source.next();
                            hasValue = !next.done;
                            if (hasValue) {
                                current = next.value;
                            }
                        }
                        catch (e) {
                            this._error = e;
                            this._stopped = true;
                        }
                    }
                    if (this._stopped) {
                        throw this._error;
                    }
                    if (hasValue) {
                        this._buffer.push(current);
                    }
                }
                else {
                    hasValue = true;
                }
                if (hasValue) {
                    yield this._buffer.get(i);
                }
                else {
                    break;
                }
                i++;
            }
        }
        finally {
            this._buffer.done();
        }
    }
}
export function memoize(source, readerCount = -1, selector) {
    if (!selector) {
        return readerCount === -1
            ? new MemoizeAsyncBuffer(source[Symbol.asyncIterator](), new MaxRefCountList())
            : new MemoizeAsyncBuffer(source[Symbol.asyncIterator](), new RefCountList(readerCount));
    }
    return create(() => selector(memoize(source, readerCount))[Symbol.asyncIterator]());
}

//# sourceMappingURL=memoize.mjs.map