dastal/lib/src/utils/iteratorUtils.js

Data Structures & Algorithms implementations

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.split = exports.skip = exports.once = exports.never = exports.join = exports.first = exports.fill = exports.always = void 0;
/**
 * Get an iterator that always returns a given value.
 */
function always(fn) {
    return { next: () => ({ done: false, value: fn() }) };
}
exports.always = always;
/**
 * Get an iterator that returns a value a given amount of times.
 */
function fill(length, fn) {
    return {
        next: () => {
            if (length < 1) {
                return { done: true, value: undefined };
            }
            --length;
            return { done: false, value: fn() };
        },
    };
}
exports.fill = fill;
/**
 * Iterate through the first num elements of an iterator.
 *
 * @param n - The number of elements to iterate.
 * @param iterator - The iterator.
 *
 * @returns - An iterator limited to the next n elements.
 */
function first(n, iterator) {
    return {
        next: () => {
            if (n < 1) {
                return { done: true, value: undefined };
            }
            const res = iterator.next();
            n = res.done ? 0 : n - 1;
            return res;
        },
    };
}
exports.first = first;
/**
 * Join multiple iterators into one.
 *
 * @param iterators - The iterators to join.
 */
function join(iterators) {
    let iterator = { next: () => ({ done: true, value: undefined }) };
    return {
        next: () => {
            if (iterator == null) {
                return { done: true, value: undefined };
            }
            let res = iterator.next();
            while (res.done) {
                const res2 = iterators.next();
                if (res2.done) {
                    iterator = undefined;
                    return { done: true, value: undefined };
                }
                iterator = res2.value;
                res = iterator.next();
            }
            return res;
        },
    };
}
exports.join = join;
/**
 * Get an empty iterator.
 */
function never() {
    return { next: () => ({ done: true, value: undefined }) };
}
exports.never = never;
/**
 * Wrap a value in an iterator.
 */
function once(fn) {
    let done = false;
    return {
        next: () => {
            const res = { done, value: fn() };
            done = true;
            fn = () => undefined;
            return res;
        },
    };
}
exports.once = once;
/**
 * Skip the next num elements of an iterator.
 *
 * @param n - The number of elements to skip.
 * @param iterator - The iterator.
 *
 * @returns - The iterator after skipping n elements.
 */
function skip(n, iterator) {
    let fn = () => {
        let res = { done: false, value: undefined };
        while (n-- > 0 && !res.done) {
            res = iterator.next();
        }
        fn = iterator.next.bind(iterator);
        return res;
    };
    return { next: () => fn() };
}
exports.skip = skip;
/**
 * Split an iterator into multiple iterators of a given length.
 *
 * @param length - The length of each iterator.
 * @param iterator - The iterator to split.
 *
 * @returns - An iterator of the resulting iterators.
 */
function split(length, iterator) {
    if (length < 1) {
        return { next: () => ({ done: true, value: undefined }) };
    }
    let done = false;
    return {
        next: () => {
            if (done) {
                return { done, value: undefined };
            }
            const iter = first(length, iterator);
            const res = iter.next();
            if (res.done) {
                done = true;
                return { done, value: undefined };
            }
            return { done, value: join([once(() => res.value), iter][Symbol.iterator]()) };
        },
    };
}
exports.split = split;
//# sourceMappingURL=iteratorUtils.js.map