@luvies/lazy/dist/iterators.d.ts

A linq-like lazy iteration module that aims to support deno, node & browser

import type { MapFn } from './aggregates';
/**
 * A function that maps one type to another, and is given the index that
 * the iterator is currently on.
 */
export declare type IndexMapFn<TSource, TResult> = (source: TSource, index: number) => TResult;
/**
 * A function that combines 2 types into another.
 */
export declare type CombineFn<TFirst, TSecond, TResult> = (first: TFirst, second: TSecond) => TResult;
/**
 * A function that takes in 2 values and returns the sorting number.
 */
export declare type SortFn<TSource> = (a: TSource, b: TSource) => number;
/**
 * A function that takes in a value and an index and returns a boolean.
 */
export declare type IndexPredicate<TSource> = (element: TSource, index: number) => boolean;
/**
 * A function that takes in a value and an index and returns whether the
 * value is of a given type.
 */
export declare type IndexIsPredicate<TSource, TResult extends TSource> = (element: TSource, index: number) => element is TResult;
/**
 * A grouping of elements based on the key.
 */
export interface IGrouping<TKey, TElement> {
    key: TKey;
    elements: Iterable<TElement>;
}
/**
 * @hidden
 */
export declare class LazyRangeIterator implements Iterator<number> {
    private readonly _end;
    private _index;
    private readonly _direction;
    constructor(_start: number, _end: number);
    next(): IteratorResult<number>;
}
/**
 * @hidden
 */
export declare class LazyRepeatIterator<TElement> implements Iterator<TElement> {
    private readonly _element;
    private readonly _count;
    private _index;
    constructor(_element: TElement, _count: number);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyAppendPrependIterator<TElement> implements Iterator<TElement> {
    private readonly _element;
    private readonly _atStart;
    private readonly _iterator;
    private _started;
    private _finished;
    constructor(iterable: Iterable<TElement>, _element: TElement, _atStart: boolean);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyBatchInIterator<TElement> implements Iterator<Iterable<TElement>> {
    private readonly _batchSize;
    private readonly _includeIncomplete;
    private readonly _iterator;
    private _done;
    constructor(iterable: Iterable<TElement>, _batchSize: number, _includeIncomplete: boolean);
    next(): IteratorResult<Iterable<TElement>>;
}
/**
 * @hidden
 */
export declare class LazyConcatIterator<TElement> implements Iterator<TElement> {
    private readonly _iterators;
    private _current;
    constructor(iterables: Array<Iterable<TElement>>);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyDefaultIfEmptyIterator<TElement> implements Iterator<TElement> {
    private readonly _defaultValue;
    private readonly _iterator;
    private _started;
    private _done;
    constructor(iterable: Iterable<TElement>, _defaultValue: TElement);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyDistinctIterator<TElement, TKey = TElement> implements Iterator<TElement> {
    private readonly _compareOn?;
    private readonly _iterator;
    private readonly _found;
    constructor(iterable: Iterable<TElement>, _compareOn?: MapFn<TElement, TKey> | undefined);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyExceptIterator<TElement, TKey = TElement> implements Iterator<TElement> {
    private readonly _compareOn?;
    private readonly _firstIterator;
    private readonly _set;
    constructor(firstIterable: Iterable<TElement>, secondIterable: Iterable<TElement>, _compareOn?: MapFn<TElement, TKey> | undefined);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyGroupByIterator<TSource, TKey, TElement = TSource, TResult = IGrouping<TKey, TElement>> implements Iterator<TResult> {
    private readonly _resultSelector?;
    private readonly _elementMapIterator;
    constructor(iterable: Iterable<TSource>, keyFn: MapFn<TSource, TKey>, elementSelector?: MapFn<TSource, TElement>, _resultSelector?: CombineFn<TKey, Iterable<TElement>, TResult> | undefined);
    next(): IteratorResult<TResult>;
}
/**
 * @hidden
 */
export declare class LazyGroupJoinIterator<TFirst, TSecond, TKey, TResult> implements Iterator<TResult> {
    private readonly _firstKeyFn;
    private readonly _joinFn;
    private readonly _firstIterator;
    private readonly _secondMap;
    constructor(firstIterable: Iterable<TFirst>, secondIterable: Iterable<TSecond>, _firstKeyFn: MapFn<TFirst, TKey>, secondKeyFn: MapFn<TSecond, TKey>, _joinFn: CombineFn<TFirst, Iterable<TSecond>, TResult>);
    next(): IteratorResult<TResult>;
}
/**
 * @hidden
 */
export declare class LazyIntersectIterator<TElement, TKey = TElement> implements Iterator<TElement> {
    private readonly _compareOn?;
    private readonly _firstIterator;
    private readonly _set;
    constructor(firstIterable: Iterable<TElement>, secondIterable: Iterable<TElement>, _compareOn?: MapFn<TElement, TKey> | undefined);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyJoinIterator<TFirst, TSecond, TKey, TResult> implements Iterator<TResult> {
    private readonly _firstKeyFn;
    private readonly _joinFn;
    private readonly _firstIterator;
    private readonly _secondMap;
    constructor(firstIterable: Iterable<TFirst>, secondIterable: Iterable<TSecond>, _firstKeyFn: MapFn<TFirst, TKey>, secondKeyFn: MapFn<TSecond, TKey>, _joinFn: CombineFn<TFirst, TSecond, TResult>);
    next(): IteratorResult<TResult>;
}
/**
 * @hidden
 */
export declare function numericComparer(a: number, b: number): number;
/**
 * @hidden
 */
export declare function lazyOrderBy<TElement, TKey>(iterable: Iterable<TElement>, keyFn: MapFn<TElement, TKey>, compareFn: SortFn<TKey> | undefined, decending: boolean): Iterator<TElement>;
/**
 * @hidden
 */
export declare class LazyReverseIterator<TElement> implements Iterator<TElement> {
    private readonly _arr;
    private _index;
    constructor(iterable: Iterable<TElement>);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazySelectIterator<TSource, TResult> implements Iterator<TResult> {
    private readonly _selector;
    private readonly _iterator;
    private _index;
    constructor(iterable: Iterable<TSource>, _selector: IndexMapFn<TSource, TResult>);
    next(): IteratorResult<TResult>;
}
/**
 * @hidden
 */
export declare class LazySelectManyIterator<TSource, TResult> implements Iterator<TResult> {
    private readonly _selector;
    private readonly _iterator;
    private _internalIterator;
    private _index;
    constructor(iterable: Iterable<TSource>, _selector: IndexMapFn<TSource, Iterable<TResult>>);
    next(): IteratorResult<TResult>;
}
/**
 * @hidden
 */
export declare class LazySkipIterator<TElement> implements Iterator<TElement> {
    private readonly _count;
    private readonly _iterator;
    private _skipped;
    constructor(iterable: Iterable<TElement>, _count: number);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazySkipLastIterator<TElement> implements Iterator<TElement> {
    private readonly _count;
    private readonly _iterator;
    private readonly _queue;
    constructor(iterable: Iterable<TElement>, _count: number);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazySkipWhile<TElement> implements Iterator<TElement> {
    private readonly _predicate;
    private readonly _iterator;
    private _index;
    private _yielding;
    constructor(iterable: Iterable<TElement>, _predicate: IndexPredicate<TElement>);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyTakeIterator<TElement> implements Iterator<TElement> {
    private readonly _count;
    private readonly _iterator;
    private _taken;
    constructor(iterable: Iterable<TElement>, _count: number);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyTakeLastIterator<TElement> implements Iterator<TElement> {
    private _queue;
    constructor(iterable: Iterable<TElement>, count: number);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyTakeWhileIterator<TElement> implements Iterator<TElement> {
    private readonly _predicate;
    private readonly _iterator;
    private _index;
    constructor(iterable: Iterable<TElement>, _predicate: IndexPredicate<TElement>);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyUnionIterator<TElement, TKey = TElement> implements Iterator<TElement> {
    private readonly _compareOn?;
    private readonly _firstIterator;
    private readonly _secondIterator;
    private readonly _set;
    private _onSecond;
    constructor(firstIterable: Iterable<TElement>, secondIterable: Iterable<TElement>, _compareOn?: MapFn<TElement, TKey> | undefined);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyWhereIterator<TElement> implements Iterator<TElement> {
    private readonly _predicate;
    private readonly _iterator;
    private _index;
    constructor(iterable: Iterable<TElement>, _predicate: IndexPredicate<TElement>);
    next(): IteratorResult<TElement>;
}
/**
 * @hidden
 */
export declare class LazyZipIterator<TFirst, TSecond, TResult = [TFirst, TSecond]> implements Iterator<TResult> {
    private readonly _selector?;
    private readonly _firstIterator;
    private readonly _secondIterator;
    constructor(firstIterable: Iterable<TFirst>, secondIterable: Iterable<TSecond>, _selector?: CombineFn<TFirst, TSecond, TResult> | undefined);
    next(): IteratorResult<TResult>;
}
//# sourceMappingURL=iterators.d.ts.map