@naturalcycles/js-lib/dist/iter/asyncIterable2.js

Standard library for universal (browser + Node.js) javascript

import { END, SKIP } from '../types.js';
/**
 * Similar to Iterable2, but for AsyncIterable.
 *
 * AsyncIterable2 is a wrapper around AsyncIterable that implements "Iterator Helpers proposal":
 * https://github.com/tc39/proposal-iterator-helpers
 *
 * AsyncIterable2 can be removed after the proposal is widely implemented in Node & browsers.
 *
 * @experimental
 */
export class AsyncIterable2 {
    it;
    constructor(it) {
        this.it = it;
    }
    static of(it) {
        return new AsyncIterable2(it);
    }
    static ofIterable(it) {
        return new AsyncIterable2({
            async *[Symbol.asyncIterator]() {
                yield* it;
            },
        });
    }
    static empty() {
        return new AsyncIterable2({
            async *[Symbol.asyncIterator]() { },
        });
    }
    [Symbol.asyncIterator]() {
        return this.it[Symbol.asyncIterator]();
    }
    async toArray() {
        // todo: Array.fromAsync is not yet available, use that when it's ready
        // return await Array.fromAsync(this.it)
        const res = [];
        for await (const item of this.it) {
            res.push(item);
        }
        return res;
    }
    async forEach(cb) {
        let i = 0;
        for await (const v of this.it) {
            if ((await cb(v, i++)) === END)
                return;
        }
    }
    async some(cb) {
        return !!(await this.find(cb));
    }
    async someSync(cb) {
        return !!(await this.findSync(cb));
    }
    async every(cb) {
        let i = 0;
        for await (const v of this.it) {
            const r = await cb(v, i++);
            if (r === END || !r)
                return false;
        }
        return true;
    }
    async everySync(cb) {
        let i = 0;
        for await (const v of this.it) {
            const r = cb(v, i++);
            if (r === END || !r)
                return false;
        }
        return true;
    }
    async find(cb) {
        let i = 0;
        for await (const v of this.it) {
            const r = await cb(v, i++);
            if (r === END)
                return;
            if (r)
                return v;
        }
    }
    async findSync(cb) {
        let i = 0;
        for await (const v of this.it) {
            const r = cb(v, i++);
            if (r === END)
                return;
            if (r)
                return v;
        }
    }
    filter(cb) {
        const { it } = this;
        return new AsyncIterable2({
            async *[Symbol.asyncIterator]() {
                let i = 0;
                for await (const v of it) {
                    const r = await cb(v, i++);
                    if (r === END)
                        return;
                    if (r)
                        yield v;
                }
            },
        });
    }
    filterSync(cb) {
        const { it } = this;
        return new AsyncIterable2({
            async *[Symbol.asyncIterator]() {
                let i = 0;
                for await (const v of it) {
                    const r = cb(v, i++);
                    if (r === END)
                        return;
                    if (r)
                        yield v;
                }
            },
        });
    }
    map(mapper) {
        const { it } = this;
        return new AsyncIterable2({
            async *[Symbol.asyncIterator]() {
                let i = 0;
                for await (const v of it) {
                    const r = await mapper(v, i++);
                    if (r === END)
                        return;
                    if (r === SKIP)
                        continue;
                    yield r;
                }
            },
        });
    }
    mapSync(mapper) {
        const { it } = this;
        return new AsyncIterable2({
            async *[Symbol.asyncIterator]() {
                let i = 0;
                for await (const v of it) {
                    const r = mapper(v, i++);
                    if (r === END)
                        return;
                    if (r === SKIP)
                        continue;
                    yield r;
                }
            },
        });
    }
}