@szilanor/stream

type OperationFunction<TInput, TOutput> = (iterable: Iterable<TInput>) => Iterable<TOutput>; type AsyncOperationFunction<TInput, TOutput> = (iterable: AsyncIterable<TInput>) => AsyncIterable<TOutput>; type CollectorFunction<TInput, TOutput> = (iterable: Iterable<TInput>) => TOutput; type AsyncCollectorFunction<TInput, TOutput> = (iterable: AsyncIterable<TInput>) => PromiseLike<TOutput>; /** Wrapper class to extend the functionality of an Iterable */ declare class AsyncStream<T> implements AsyncIterable<T> { private readonly asyncIterable; [Symbol.asyncIterator](): AsyncIterator<T>; constructor(asyncIterable?: AsyncIterable<T> | null); /** Calls a collector function on the Iterable */ collectAsync<O>(collector: AsyncCollectorFunction<T, O>): PromiseLike<O>; /** Calls an operation function on the Iterable then returns the result as a Stream * allowing to chain it with more Stream related methods. */ pipeAsync(): AsyncStream<T>; pipeAsync<A>(op1: AsyncOperationFunction<T, A>): AsyncStream<A>; pipeAsync<A, B>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>): AsyncStream; pipeAsync<A, B, C>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>): AsyncStream<C>; pipeAsync<A, B, C, D>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>): AsyncStream<D>; pipeAsync<A, B, C, D, E>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>, op5: AsyncOperationFunction<D, E>): AsyncStream<E>; pipeAsync<A, B, C, D, E, F>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>, op5: AsyncOperationFunction<D, E>, op6: AsyncOperationFunction<E, F>): AsyncStream<F>; pipeAsync<A, B, C, D, E, F, G>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>, op5: AsyncOperationFunction<D, E>, op6: AsyncOperationFunction<E, F>, op7: AsyncOperationFunction<F, G>): AsyncStream<G>; pipeAsync<A, B, C, D, E, F, G, H>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>, op5: AsyncOperationFunction<D, E>, op6: AsyncOperationFunction<E, F>, op7: AsyncOperationFunction<F, G>, op8: AsyncOperationFunction<G, H>): AsyncStream<H>; pipeAsync<A, B, C, D, E, F, G, H, I>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>, op5: AsyncOperationFunction<D, E>, op6: AsyncOperationFunction<E, F>, op7: AsyncOperationFunction<F, G>, op8: AsyncOperationFunction<G, H>, op9: AsyncOperationFunction<H, I>): AsyncStream<H>; pipeAsync<A, B, C, D, E, F, G, H, I>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>, op5: AsyncOperationFunction<D, E>, op6: AsyncOperationFunction<E, F>, op7: AsyncOperationFunction<F, G>, op8: AsyncOperationFunction<G, H>, op9: AsyncOperationFunction<H, I>): AsyncStream; pipeAsync(...ops: AsyncOperationFunction<T, T>[]): AsyncStream<T>; } /** Wrapper class to extend the functionality of an Iterable */ declare class Stream<T> extends AsyncStream<T> implements Iterable<T> { private readonly iterable; constructor(iterable?: Iterable<T> | null); [Symbol.iterator](): Iterator<T>; [Symbol.asyncIterator](): AsyncIterator<T>; /** Calls a collector function on the Iterable */ collect<O>(collector: CollectorFunction<T, O>): O; /** Calls an operation function on the Iterable then returns the result as a Stream * allowing to chain it with more Stream related methods. */ pipe(): Stream<T>; pipe<A>(op1: OperationFunction<T, A>): Stream<A>; pipe<A, B>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>): Stream; pipe<A, B, C>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>): Stream<C>; pipe<A, B, C, D>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>): Stream<D>; pipe<A, B, C, D, E>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>, op5: OperationFunction<D, E>): Stream<E>; pipe<A, B, C, D, E, F>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>, op5: OperationFunction<D, E>, op6: OperationFunction<E, F>): Stream<F>; pipe<A, B, C, D, E, F, G>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>, op5: OperationFunction<D, E>, op6: OperationFunction<E, F>, op7: OperationFunction<F, G>): Stream<G>; pipe<A, B, C, D, E, F, G, H>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>, op5: OperationFunction<D, E>, op6: OperationFunction<E, F>, op7: OperationFunction<F, G>, op8: OperationFunction<G, H>): Stream<H>; pipe<A, B, C, D, E, F, G, H, I>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>, op5: OperationFunction<D, E>, op6: OperationFunction<E, F>, op7: OperationFunction<F, G>, op8: OperationFunction<G, H>, op9: OperationFunction<H, I>): Stream<H>; pipe<A, B, C, D, E, F, G, H, I>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>, op5: OperationFunction<D, E>, op6: OperationFunction<E, F>, op7: OperationFunction<F, G>, op8: OperationFunction<G, H>, op9: OperationFunction<H, I>): Stream; pipe(...ops: OperationFunction<T, T>[]): Stream<T>; } /** * Returns a Stream that yields elements of all Iterable parameters in order. * @param iterables Iterables to concatenate. * @typeParam T Type of items in the Iterables. * @returns Stream that yields elements of all Iterables in order. */ declare function concat<T>(...iterables: Array<Iterable<T>>): Stream<T>; declare const chain: typeof concat; /** * Returns a Stream that yields elements of all Iterable parameters in order. */ declare function concatAsync<T>(...iterables: Array<Iterable<T> | AsyncIterable<T>>): AsyncStream<T>; declare const chainAsync: typeof concatAsync; /** * Returns a Stream that infinitely yields elements of the Iterable parameter. */ declare function cycle<T>(iterable: Iterable<T>): Stream<T>; /** * Returns a Stream that is empty. * @typeParam T Type of items in the Stream. * @returns Stream that is empty. * * @example * ```typescript * const result = empty(); * console.log([...result]); // [] * ``` */ declare function empty<T>(): Stream<T>; /** * Returns a Stream that yields the elements of the Iterable parameter. * @typeParam T Type of items in the Stream. * @param iterable Iterable to create the Stream from. * @returns Stream that yields the elements of the Iterable. * * @example * ```typescript * const result = from('ABCD'); * console.log([...result]); // ['A', 'B', 'C', 'D'] * ``` */ declare function from<T>(iterable?: Iterable<T>): Stream<T>; declare const stream: typeof from; /** * Creates a Stream from an iterable (Array, Set, Map, Stream...) */ declare function fromAsync<T>(iterable?: AsyncIterable<T>): AsyncStream<T>; declare const streamAsync: typeof fromAsync; /** * Returns a Stream that yields the specified entries. * @typeParam T Type of items in the Stream. * @param entries Entries to create the Stream from. * @returns Stream that yields the specified entries. * * @example * ```typescript * const result = of(1, 2, 3); * console.log([...result]); // [1, 2, 3] * ``` */ declare function of<T>(...entries: T[]): Stream<T>; declare const streamOf: typeof of; /** * Returns a Stream that merges elements from both iterables by taking one * element from each, passing them to the function, and yielding the result. * * @param a The first iterable to merge. * @param b The second iterable to merge. * @param productFunction The function that merges the elements. * @returns A Stream that merges elements from both iterables. * * @example * ```typescript * const result = product('ABCD', 'xy', (a, b) => `${a}${b}`); * console.log([...result]); // ['Ax', 'Ay', 'Bx', 'By', 'Cx', 'Cy', 'Dx', 'Dy'] * ``` */ declare function product<A, B, O>(a: Iterable<A>, b: Iterable, productFunction: (a: A, b: B) => O): Stream<O>; /** * Returns a Stream that yields numbers starting from 'start' up to 'start + count - 1'. * @param start The first number in the range. * @param count The number of elements in the range. * @param by The step between elements. * @returns A Stream that yields numbers in the range. * * @example * ```typescript * const result = range(1, 5, 2); * console.log([...result]); // [1, 3, 5] * ``` */ declare function range(start: number, count: number, by?: number): Stream<number>; declare function isNotNull<T>(value: T | null | undefined): value is NonNullable<T>; declare function isFunction(x: unknown): x is Function; declare function isIterable<T>(x: Iterable<T> | AsyncIterable<T>): x is Iterable<T>; declare function isNotNullOrEmpty<T extends { length: number; }>(value: T | null | undefined): value is NonNullable<T>; declare function isNotNullOrWhitespace(value: string | null | undefined): value is NonNullable<string>; type EqualsFunction<T> = (a: T, b: T) => boolean; type CompareFunction<T> = (a: T, b: T) => number; type MaybeAsyncValue<T> = T | PromiseLike<T>; type ReduceFunction<T, O = T> = (previous: O, current: T, index: number) => O; type AsyncReduceFunction<T, O = T> = (previous: O, current: T, index: number) => MaybeAsyncValue<O>; type ValueOrFactory<T> = T | (() => T); type PredicateFunction<T> = (item: T, index: number) => boolean; type MaybeAsyncPredicateFunction<T> = (item: T, index: number) => boolean | Promise<boolean>; type TypeGuardFunction<T, TOfType extends T> = (item: T, index: number) => item is TOfType; type CallbackFunction<T> = (item: T, index: number) => void; type MaybeAsyncCallbackFunction<T> = (item: T, index: number) => void | Promise<void>; type MapperFunction<T, O> = (item: T, index: number) => O; type AsyncMapperFunction<T, O> = (item: T, index: number) => PromiseLike<O>; /** * Returns a Stream that yields the same value 'times' number of times. * @param value Value to repeat. * @param times Number of times to repeat the value. * @typeParam T Type of the value. * @returns A Stream that yields the value 'times' number of times. * * @example * ```typescript * const result = repeat('A', 3); * console.log([...result]); // ['A', 'A', 'A'] * ``` */ declare function repeat<T>(value: ValueOrFactory<T>, times?: number): Stream<T>; /** * Returns a Stream that merges elements from both iterables by taking one * element from each, passing them to the function, and yielding the result. * * @param a The first iterable to merge. * @param b The second iterable to merge. * @param zipFunction The function that merges the elements. * @returns A Stream that merges elements from both iterables. * * @example * ```typescript * const result = zip('ABCD', 'xy', (a, b) => `${a}${b}`); * console.log([...result]); // ['Ax', 'By'] * ``` */ declare function zip<A, B, O>(a: Iterable<A>, b: Iterable, zipFunction: (a: A, b: B) => O): Stream<O>; /** * Returns a Stream that merges elements from both iterables by taking one * element from each, passing them to the function, and yielding the result. */ declare function zipAsync<A, B, O>(a: AsyncIterable<A>, b: AsyncIterable, zipFunction: (a: A, b: B) => O): AsyncStream<O>; /** * Returns a Stream that merges elements from both iterables by taking one * element from each, passing them to the function, and yielding the result. * * @param a The first iterable to merge. * @param b The second iterable to merge. * @param fillValue The value or factory to use when one iterable is done. * @param zipFunction The function that merges the elements. * @returns A Stream that merges elements from both iterables. * * @example * ```typescript * const result = zipLongest('ABCD', 'xy', ' ', (a, b) => `${a}${b}`); * console.log([...result]); // ['Ax', 'By', 'C ', 'D '] * ``` */ declare function zipLongest<A, B, F, O>(a: Iterable<A>, b: Iterable, fillValue: ValueOrFactory<F>, zipFunction: (a: A | F, b: B | F) => O): Stream<O>; /** * Appends the given Iterables to the end of the source Iterable. * @param iterables Iterables to append. * @typeParam T Type of items in the Iterables. * @returns Returns a new Iterable that yields the elements of the source Iterable followed by the elements of the given Iterables. * * @example * ```typescript * const result = appendWith([4, 5, 6], [7, 8, 9])([1, 2, 3]); * console.log([...result]); // [1, 2, 3, 4, 5, 6, 7, 8, 9] * ``` */ declare function appendWith<T>(...iterables: Iterable<T>[]): OperationFunction<T, T>; /** Concatenates the Iterable with other Iterables in order */ declare function appendWithAsync<T>(...iterables: Iterable<T>[]): AsyncOperationFunction<T, T>; /** Returns an Iterable that yields only array entries of the source Iterable that satisfy the function. */ declare function arrayFilter<T>(predicate: (entry: T, index: number) => boolean): OperationFunction<T[], T[]>; /** Returns an Iterable that yields array entries of the source Iterable transformed using the function */ declare function arrayMap<T, O>(mapper: (entry: T, index: number) => O): OperationFunction<T[], O[]>; /** * Buffers the source elements into arrays of 'size' elements. * @param size The number of elements in each buffer. * @typeParam T Type of the elements. * @returns Operation that buffers the source elements. * * @example * ```typescript * const result = buffer(3)([1, 2, 3, 4, 5, 6]); * console.log([...result]); // [[1, 2, 3], [4, 5, 6]] * ``` */ declare function buffer<T>(size: number): OperationFunction<T, T[]>; /** Returns an Iterable that yields array of entries of the source Iterable with the given length. */ declare function bufferAsync<T>(size: number): AsyncOperationFunction<T, T[]>; /** Type-safe helper operation that concatenates multiple operations in order. */ declare function compound<T>(): OperationFunction<T, T>; declare function compound<T, A>(op1: OperationFunction<T, A>): OperationFunction<T, A>; declare function compound<T, A, B>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>): OperationFunction<T, B>; declare function compound<T, A, B, C>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>): OperationFunction<T, C>; declare function compound<T, A, B, C, D>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>): OperationFunction<T, D>; declare function compound<T, A, B, C, D, E>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>, op5: OperationFunction<D, E>): OperationFunction<T, E>; declare function compound<T, A, B, C, D, E, F>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>, op5: OperationFunction<D, E>, op6: OperationFunction<E, F>): OperationFunction<T, F>; declare function compound<T, A, B, C, D, E, F, G>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>, op5: OperationFunction<D, E>, op6: OperationFunction<E, F>, op7: OperationFunction<F, G>): OperationFunction<T, G>; declare function compound<T, A, B, C, D, E, F, G, H>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>, op5: OperationFunction<D, E>, op6: OperationFunction<E, F>, op7: OperationFunction<F, G>, op8: OperationFunction<G, H>): OperationFunction<T, H>; declare function compound<T, A, B, C, D, E, F, G, H, I>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>, op5: OperationFunction<D, E>, op6: OperationFunction<E, F>, op7: OperationFunction<F, G>, op8: OperationFunction<G, H>, op9: OperationFunction<H, I>): OperationFunction<T, I>; declare function compound<T, A, B, C, D, E, F, G, H, I, J>(op1: OperationFunction<T, A>, op2: OperationFunction<A, B>, op3: OperationFunction<B, C>, op4: OperationFunction<C, D>, op5: OperationFunction<D, E>, op6: OperationFunction<E, F>, op7: OperationFunction<F, G>, op8: OperationFunction<G, H>, op9: OperationFunction<H, I>, op10: OperationFunction<I, J>): OperationFunction<T, J>; declare const pipe: typeof compound; /** Type-safe helper operation that concatenates multiple operations in order. */ declare function compoundAsync<T>(): AsyncOperationFunction<T, T>; declare function compoundAsync<T, A>(op1: AsyncOperationFunction<T, A>): AsyncOperationFunction<T, A>; declare function compoundAsync<T, A, B>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>): AsyncOperationFunction<T, B>; declare function compoundAsync<T, A, B, C>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>): AsyncOperationFunction<T, C>; declare function compoundAsync<T, A, B, C, D>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>): AsyncOperationFunction<T, D>; declare function compoundAsync<T, A, B, C, D, E>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>, op5: AsyncOperationFunction<D, E>): AsyncOperationFunction<T, E>; declare function compoundAsync<T, A, B, C, D, E, F>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>, op5: AsyncOperationFunction<D, E>, op6: AsyncOperationFunction<E, F>): AsyncOperationFunction<T, F>; declare function compoundAsync<T, A, B, C, D, E, F, G>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>, op5: AsyncOperationFunction<D, E>, op6: AsyncOperationFunction<E, F>, op7: AsyncOperationFunction<F, G>): AsyncOperationFunction<T, G>; declare function compoundAsync<T, A, B, C, D, E, F, G, H>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>, op5: AsyncOperationFunction<D, E>, op6: AsyncOperationFunction<E, F>, op7: AsyncOperationFunction<F, G>, op8: AsyncOperationFunction<G, H>): AsyncOperationFunction<T, H>; declare function compoundAsync<T, A, B, C, D, E, F, G, H, I>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>, op5: AsyncOperationFunction<D, E>, op6: AsyncOperationFunction<E, F>, op7: AsyncOperationFunction<F, G>, op8: AsyncOperationFunction<G, H>, op9: AsyncOperationFunction<H, I>): AsyncOperationFunction<T, I>; declare function compoundAsync<T, A, B, C, D, E, F, G, H, I, J>(op1: AsyncOperationFunction<T, A>, op2: AsyncOperationFunction<A, B>, op3: AsyncOperationFunction<B, C>, op4: AsyncOperationFunction<C, D>, op5: AsyncOperationFunction<D, E>, op6: AsyncOperationFunction<E, F>, op7: AsyncOperationFunction<F, G>, op8: AsyncOperationFunction<G, H>, op9: AsyncOperationFunction<H, I>, op10: AsyncOperationFunction<I, J>): AsyncOperationFunction<T, unknown>; declare const pipeAsync: typeof compoundAsync; /** * Concatenates the given Iterables to the end of the source Iterable. * @param iterables Iterables to concatenate. * @typeParam T Type of items in the Iterables. * @returns Returns a new Iterable that yields the elements of the source Iterable followed by the elements of the given Iterables. * * @example * ```typescript * const result = concatWith([4, 5, 6], [7, 8, 9])([1, 2, 3]); * console.log([...result]); // [1, 2, 3, 4, 5, 6, 7, 8, 9] * ``` */ declare function concatWith<T>(...iterables: Iterable<T>[]): OperationFunction<T, T>; /** Concatenates the Iterable with other Iterables in order */ declare function concatWithAsync<T>(...iterables: Array<AsyncIterable<T> | Iterable<T>>): AsyncOperationFunction<T, T>; /** * Emits a default value if the source is empty. * @param defaultValue Value to emit if the source is empty. * @typeParam T Type of items emitted by the source. * @returns Operation that emits a default value if the source is empty. * * @example * ```typescript * const result = defaultIfEmpty('A')([]); * console.log([...result]); // ['A'] * ``` */ declare function defaultIfEmpty<T>(defaultValue: ValueOrFactory<T>): OperationFunction<T, T>; /** Returns an Iterable with the value parameter if the source Iterable is empty. */ declare function defaultIfEmptyAsync<T>(defaultValue: ValueOrFactory<T>): AsyncOperationFunction<T, T>; /** * Returns a Stream that yields distinct elements from the source. * @typeParam T Type of items in the source. * @returns Operation that yields distinct elements from the source. * * @example * ```typescript * const result = distinct()([1, 2, 1, 3, 2, 4]); * console.log([...result]); // [1, 2, 3, 4] * ``` */ declare function distinct<T>(): OperationFunction<T, T>; /** Returns an Iterable that yields only entries of the source Iterable without duplicates. */ declare function distinctAsync<T>(): AsyncOperationFunction<T, T>; /** * Returns a Stream that yields distinct elements from the source based on the equals function. * @param equalsFunction Function to compare elements. * @typeParam T Type of items in the source. * @returns Operation that yields distinct elements from the source. * * @example * ```typescript * const result = distinctBy<number>((a, b) => a % 2 === b % 2)([1, 2, 1, 3, 2, 4]); * console.log([...result]); // [1, 2] * ``` */ declare function distinctBy<T>(equalsFunction?: EqualsFunction<T>): OperationFunction<T, T>; /** Returns an Iterable that yields only entries of the source Iterable without duplicates. */ declare function distinctByAsync<T>(equalsFunction?: EqualsFunction<T>): AsyncOperationFunction<T, T>; /** * Returns a Stream that yields elements from the source that are distinct from the previous element. * @param equalsFunction Function to compare elements. * @typeParam T Type of items in the source. * @returns Operation that yields elements from the source that are distinct from the previous element. * * @example * ```typescript * const result = distinctUntilChanged<number>()([1, 1, 2, 2, 3, 3]); * console.log([...result]); // [1, 2, 3] * ``` */ declare function distinctUntilChanged<T>(equalsFunction?: EqualsFunction<T>): OperationFunction<T, T>; /** Returns an Iterable that yields only entries of the source Iterable without duplicates. */ declare function distinctUntilChangedAsync<T>(equalsFunction?: EqualsFunction<T>): AsyncOperationFunction<T, T>; /** * Returns a Stream that yields elements from the source that are distinct from the previous element based on the key. * @param key Key to compare elements. * @param equalsFunction Function to compare elements. * @typeParam T Type of items in the source. * * @example * ```typescript * const result = distinctUntilKeyChanged('a')([{ a: 1 }, { a: 1 }, { a: 2 }, { a: 2 }, { a: 3 }, { a: 3 }]); * console.log([...result]); // [{ a: 1 }, { a: 2 }, { a: 3 }] * ``` */ declare function distinctUntilKeyChanged<T, K extends keyof T>(key: K, equalsFunction?: EqualsFunction<T[K]>): OperationFunction<T, T>; declare function distinctUntilKeyChangedAsync<T, K extends keyof T>(key: K, equalsFunction?: EqualsFunction<T[K]>): AsyncOperationFunction<T, T>; /** * Concatenates the given values to the end of the source Iterable. * @param values Values to concatenate. * @typeParam T Type of items in the Iterables. * @returns Returns a new Iterable that yields the elements of the source Iterable followed by the given values. * * @example * ```typescript * const result = endWith(4, 5, 6)([1, 2, 3]); * console.log([...result]); // [1, 2, 3, 4, 5, 6] * ``` */ declare function endWith<T>(...values: T[]): OperationFunction<T, T>; /** Returns an Iterable with the entries of the source Iterable then the parameter value. */ declare function endWithAsync<T>(...values: T[]): AsyncOperationFunction<T, T>; /** * Returns a Stream that yields elements that are falsy. * @typeParam T Type of items in the source. * @returns Operation that yields elements that are falsy. * * @example * ```typescript * const result = falsy<number>()([0, 1, 2, 3, 4]); * console.log([...result]); // [0] * ``` */ declare function falsy<T>(): OperationFunction<T, T>; /** Returns an Iterable that yields only entries of the source Iterable with falsy value. */ declare function falsyAsync<T>(): AsyncOperationFunction<T, T>; /** * Returns a Stream that yields elements from the source that satisfy the predicate. * @param predicate Predicate to filter elements. * @typeParam T Type of items in the source. * @returns Operation that yields elements from the source that satisfy the predicate. * * @example * ```typescript * const result = filter((x) => x % 2 === 0)([1, 2, 3, 4, 5]); * console.log([...result]); // [2, 4] * ``` */ declare function filter<T, TOfType extends T = T>(predicate: PredicateFunction<T> | TypeGuardFunction<T, TOfType>): OperationFunction<T, T>; /** Returns an Iterable that yields only entries of the source Iterable that satisfy the function. */ declare function filterAsync<T>(predicate: PredicateFunction<T>): AsyncOperationFunction<T, T>; /** * Returns a Stream that yields elements from the source that are Iterable and flattens them. * @typeParam T Type of items in the source. * @returns Operation that yields elements from the source that are Iterable and flattens them. * * @example * ```typescript * const result = flat<number>()([[1, 2], [3, 4]]); * console.log([...result]); // [1, 2, 3, 4] * ``` */ declare function flat<T>(): OperationFunction<Iterable<T>, T>; declare const flatten: typeof flat; /** Returns an Iterable that yields the inner entries of array entries of the source Iterable. */ declare function flatAsync<T>(): AsyncOperationFunction<Iterable<T>, T>; declare const flattenAsync: typeof flatAsync; /** * Maps each element to an Iterable and flattens the result. * @param mapper Mapping function. * @typeParam T Type of items in the source. * @typeParam O Type of items in the resulting Iterable. * @returns Operation that maps each element to an Iterable and flattens the result. * * @example * ```typescript * const result = flatMap<number, number>((value) => [value, value + 1])([1, 2, 3]); * console.log([...result]); // [1, 2, 2, 3, 3, 4] * ``` */ declare function flatMap<T, O>(mapper: (value: T, index: number) => Iterable<O>): OperationFunction<T, O>; /** * Returns an Iterable that yields the inner entries of the * result produced by the function. */ declare function flatMapAsync<T, O>(mapper: (value: T, index: number) => Iterable<O>): AsyncOperationFunction<T, O>; /** * Returns a Stream that yields elements from the source transformed by the mapper. * @param mapper Function to transform elements. * @typeParam T Type of items in the source. * @typeParam O Type of items in the result. * @returns Operation that yields elements from the source transformed by the mapper. * * @example * ```typescript * const result = map((x) => x * 2)([1, 2, 3]); * console.log([...result]); // [2, 4, 6] * ``` */ declare function map<T, O>(mapper: (value: T, index: number) => O): OperationFunction<T, O>; /** Returns an Iterable that yields entries of the source Iterable transformed using the function */ declare function mapAsync<T, O>(mapper: MapperFunction<T, O> | AsyncMapperFunction<T, O>): AsyncOperationFunction<T, O>; /** * Returns a Stream that yields the same elements as the source. * @typeParam T Type of items in the source. * @returns Operation that yields the same elements as the source. * * @example * ```typescript * const result = noop<number>()([1, 2, 3]); * console.log([...result]); // [1, 2, 3] * ``` */ declare function noop<T>(): OperationFunction<T, T>; /** Simply returns every entry from the source Iterable */ declare function noopAsync<T>(): AsyncOperationFunction<T, T>; /** * Returns a Stream that yields elements that are not `null`, `undefined`, or empty. * @typeParam T Type of items in the source. * @returns Operation that yields elements that are not `null`, `undefined`, or empty. * * @example * ```typescript * const result = notNullOrEmpty<string>()(["", "a", null, "b", undefined, "c"]); * console.log([...result]); // ["a", "b", "c"] * ``` */ declare function notNullOrEmpty<T extends { length: number; }>(): OperationFunction<T | null | undefined, NonNullable<T>>; /** Returns an Iterable that yields only the non-null / non-undefined / non-empty entries of the source Iterable. */ declare function notNullOrEmptyAsync<T extends { length: number; }>(): AsyncOperationFunction<T | undefined | null, NonNullable<T>>; /** * Returns a Stream that yields elements that are not `null`, `undefined`, or whitespace. * @returns Operation that yields elements that are not `null`, `undefined`, or whitespace. * * @example * ```typescript * const result = notNullOrWhitespace<string>()(["", "a", null, "b", undefined, "c", " "]); * console.log([...result]); // ["a", "b", "c"] * ``` */ declare function notNullOrWhitespace(): OperationFunction<string | null | undefined, NonNullable<string>>; /** Returns an Iterable that yields only the non-null / non-undefined / non-empty entries of the source Iterable. */ declare function notNullOrWhitespaceAsync(): AsyncOperationFunction<string | null | undefined, NonNullable<string>>; /** * Returns a Stream that yields elements that are of the specified type. * @typeParam T Type of items in the source. * @typeParam TOfType Type of items to yield. * @param predicate A function that determines if an item is of the specified type. * @returns Operation that yields elements that are of the specified type. * * @example * ```typescript * const result = ofType<string, string>()(Number)(["a", 1, "b", 2]); * console.log([...result]); // [1, 2] * ``` */ declare function ofType<T, TOfType extends T = T>(predicate: TypeGuardFunction<T, TOfType>): OperationFunction<T, TOfType>; /** Returns and casts an Iterable that yields only entries of the source Iterable that satisfy the given type-guard function. */ declare function ofTypeAsync<T, TOfType extends T = T>(predicate: TypeGuardFunction<T, TOfType>): AsyncOperationFunction<T, TOfType>; /** * Returns a Stream that yields pairs of consecutive elements from the source. * @typeParam T Type of items in the source. * @returns Operation that yields pairs of consecutive elements from the source. * * @example * ```typescript * const result = pairwise<number>()([1, 2, 3, 4]); * console.log([...result]); // [[1, 2], [2, 3], [3, 4]] * ``` */ declare function pairwise<T>(): OperationFunction<T, [T, T]>; /** Returns an Iterable that yields the current and the previous entry of the source Iterable. */ declare function pairwiseAsync<T>(): AsyncOperationFunction<T, [T, T]>; /** * Skips the first `count` elements from the source. * @param count Number of elements to skip. * @typeParam T Type of items in the source. * @returns Operation that skips the first `count` elements from the source. * * @example * ```typescript * const result = skip<number>(2)([1, 2, 3, 4]); * console.log([...result]); // [3, 4] * ``` */ declare function skip<T>(count: number): OperationFunction<T, T>; /** Returns an Iterable skipping the given amount of entries of the source Iterable. */ declare function skipAsync<T>(count: number): AsyncOperationFunction<T, T>; /** * Skips elements from the source while the predicate returns `true`. * @param predicate Predicate function to determine if an element should be skipped. * @typeParam T Type of items in the source. * @returns Operation that skips elements from the source while the predicate returns `true`. * * @example * ```typescript * const result = skipWhile<number>((x) => x < 3)([1, 2, 3, 4]); * console.log([...result]); // [3, 4] * ``` */ declare function skipWhile<T>(predicate: PredicateFunction<T>): OperationFunction<T, T>; /** Returns an Iterable skipping entries of the source Iterable while the parameter function returns true. */ declare function skipWhileAsync<T>(predicate: PredicateFunction<T>): AsyncOperationFunction<T, T>; /** * Returns a Stream that yields elements from the source followed by the provided values. * @typeParam T Type of items in the source. * @param values Values to yield after the source. * @returns Operation that yields elements from the source followed by the provided values. * * @example * ```typescript * const result = startWith(0, 1, 2)([3, 4, 5]); * console.log([...result]); // [0, 1, 2, 3, 4, 5] * ``` */ declare function startWith<T>(...values: T[]): OperationFunction<T, T>; /** Returns an Iterable started with the value parameter then the entries of the source Iterable. */ declare function startWithAsync<T>(...values: T[]): AsyncOperationFunction<T, T>; /** * Takes the first `count` elements from the source. * @param count Number of elements to take. * @typeParam T Type of items in the source. * @returns Operation that takes the first `count` elements from the source. * * @example * ```typescript * const result = take<number>(2)([1, 2, 3, 4]); * console.log([...result]); // [1, 2] * ``` */ declare function take<T>(count: number): OperationFunction<T, T>; /** Returns an Iterable taking the given amount of entries of the source Iterable. */ declare function takeAsync<T>(count: number): AsyncOperationFunction<T, T>; /** * Takes elements from the source while the predicate returns `true`. * @param predicate Predicate function to determine if an element should be taken. * @typeParam T Type of items in the source. * @returns Operation that takes elements from the source while the predicate returns `true`. * * @example * ```typescript * const result = takeWhile<number>((x) => x < 3)([1, 2, 3, 4]); * console.log([...result]); // [1, 2] * ``` */ declare function takeWhile<T>(predicate: PredicateFunction<T>): OperationFunction<T, T>; /** Returns an Iterable taking entries of the source Iterable while the parameter function returns true. */ declare function takeWhileAsync<T>(predicate: PredicateFunction<T>): AsyncOperationFunction<T, T>; /** * Invokes a callback for each element in the source. * @param callback Callback function to invoke for each element. * @typeParam T Type of items in the source. * @returns Operation that invokes a callback for each element in the source. * * @example * ```typescript * const result = tap<number>((x) => console.log(x))([1, 2, 3]); * // Logs: * // 1 * // 2 * // 3 * console.log([...result]); // [1, 2, 3] * ``` */ declare function tap<T>(callback: CallbackFunction<T>): OperationFunction<T, T>; /** Calls a callback function on each entry */ declare function tapAsync<T>(callback: CallbackFunction<T>): AsyncOperationFunction<T, T>; /** * Returns a Stream that yields truthy elements from the source. * @typeParam T Type of items in the source. * @returns Operation that yields truthy elements from the source. * * @example * ```typescript * const result = truthy<number>()([0, 1, 2, 3]); * console.log([...result]); // [1, 2, 3] * ``` */ declare function truthy<T>(): OperationFunction<T, T>; /** Returns an Iterable that yields only entries of the source Iterable with truthy value. */ declare function truthyAsync<T>(): AsyncOperationFunction<T, T>; /** * Checks if all elements in the source satisfy the predicate. * @param predicate Predicate function to determine if an element satisfies a condition. * @typeParam T Type of items in the source. * @returns Collector that checks if all elements in the source satisfy the predicate. * * @example * ```typescript * const result = all<number>((x) => x > 0)([1, 2, 3]); * console.log(result); // true * ``` */ declare function all<T>(predicate: PredicateFunction<T>): CollectorFunction<T, boolean>; declare const every: typeof all; /** Returns true if all entries satisfy the 'predicate' function. */ declare function allAsync<T>(predicate: MaybeAsyncPredicateFunction<T>): AsyncCollectorFunction<T, boolean>; declare const everyAsync: typeof allAsync; /** * Checks if any element in the source satisfies the predicate. * @param predicate Predicate function to determine if an element satisfies a condition. * @typeParam T Type of items in the source. * @returns Collector that checks if any element in the source satisfies the predicate. * * @example * ```typescript * const result = any<number>((x) => x > 2)([1, 2, 3]); * console.log(result); // true * ``` */ declare function any<T>(predicate?: PredicateFunction<T>): CollectorFunction<T, boolean>; declare const some: typeof any; /** Returns true if at least one of the entries satisfies the 'predicate' function. */ declare function anyAsync<T>(predicate?: MaybeAsyncPredicateFunction<T>): AsyncCollectorFunction<T, boolean>; declare const someAsync: typeof anyAsync; /** * Checks if the source contains a specific value. * @param value Value to check for. * @param equalsFunction Optional function to compare values. * @typeParam T Type of items in the source. * @returns Collector that checks if the source contains a specific value. * * @example * ```typescript * const result = contains(2)([1, 2, 3]); * console.log(result); // true * ``` */ declare function contains<T>(value: T, equalsFunction?: EqualsFunction<T>): CollectorFunction<T, boolean>; declare const includes: typeof contains; /** Returns if at least one of the entries equals with the given 'value'. */ declare function containsAsync<T>(value: T, equalsFunction?: EqualsFunction<T>): AsyncCollectorFunction<T, boolean>; declare const includesAsync: typeof containsAsync; /** * Counts the number of elements in the source. * @param predicateFunction Predicate function to determine if an element should be counted. * @typeParam T Type of items in the source. * @returns Collector that counts the number of elements in the source. * * @example * ```typescript * const result = count<number>()([1, 2, 3]); * console.log(result); // 3 * ``` */ declare function count<T>(predicateFunction?: PredicateFunction<T>): CollectorFunction<T, number>; declare const length: typeof count; /** Returns the number of entries in the Iterable. */ declare function countAsync<T>(predicateFunction?: PredicateFunction<T>): AsyncCollectorFunction<T, number>; declare const lengthAsync: typeof countAsync; /** * Gets the element at the specified index. * @param index Index of the element to get. * @typeParam T Type of items in the source. * @returns Collector that gets the element at the specified index. * * @example * ```typescript * const result = elementAt<number>(1)([1, 2, 3]); * console.log(result); // 2 * ``` */ declare function elementAt<T>(index: number): CollectorFunction<T, T | undefined>; /** Returns the nth entry from the Iterable. */ declare function elementAtAsync<T>(index: number): AsyncCollectorFunction<T, T | undefined>; /** * Returns the first element in the source that satisfies the predicate. * @param predicate Predicate function to determine if an element should be returned. * @typeParam T Type of items in the source. * @returns Collector that returns the first element in the source that satisfies the predicate. * * @example * ```typescript * const result = first<number>((x) => x > 1)([1, 2, 3]); * console.log(result); // 2 * ``` */ declare function first<T>(predicate?: PredicateFunction<T>): CollectorFunction<T, T | undefined>; declare const find: typeof first; /** Returns the first entry from the Iterable that satisfy then 'predicate' function. */ declare function firstAsync<T>(predicate?: MaybeAsyncPredicateFunction<T>): AsyncCollectorFunction<T, T | undefined>; declare const findAsync: typeof firstAsync; /** * Returns the index of the first element in the source that satisfies the predicate. * @param predicate Predicate function to determine if an element should be returned. * @typeParam T Type of items in the source. * @returns Collector that returns the index of the first element in the source that satisfies the predicate. * * @example * ```typescript * const result = firstIndex<number>((x) => x > 1)([1, 2, 3]); * console.log(result); // 1 * ``` */ declare function firstIndex<T>(predicate?: PredicateFunction<T>): CollectorFunction<T, number>; declare const findIndex: typeof firstIndex; /** Returns the index of the first entry from the Iterable that satisfy then 'predicate' function. */ declare function firstIndexAsync<T>(predicate?: MaybeAsyncPredicateFunction<T>): AsyncCollectorFunction<T, number>; declare const findIndexAsync: typeof firstIndexAsync; /** * Returns the first element in the source that satisfies the predicate or a default value. * @param defaultValue Default value or factory to use if no element satisfies the predicate. * @param predicate Predicate function to determine if an element should be returned. * @typeParam T Type of items in the source. * @returns Collector that returns the first element in the source that satisfies the predicate or a default value. * * @example * ```typescript * const result = firstOrDefault<number>(0, (x) => x > 1)([1, 2, 3]); * console.log(result); // 2 * ``` */ declare function firstOrDefault<T>(defaultValue: ValueOrFactory<T>, predicate?: PredicateFunction<T>): CollectorFunction<T, T>; declare const findOrDefault: typeof firstOrDefault; /** Returns the first entry from the Iterable that satisfy then 'predicate' function or the 'defaultValue'. */ declare function firstOrDefaultAsync<T>(defaultValue: ValueOrFactory<T>, predicate?: MaybeAsyncPredicateFunction<T>): AsyncCollectorFunction<T, T>; declare const findOrDefaultAsync: typeof firstOrDefaultAsync; /** * Executes a callback for each element in the source. * @param callback Callback function to execute for each element. * @typeParam T Type of items in the source. * @returns Collector that executes a callback for each element in the source. * * @example * ```typescript * forEach<number>((x) => console.log(x))([1, 2, 3]); * // 1 * // 2 * // 3 * ``` */ declare function forEach<T>(callback: CallbackFunction<T>): CollectorFunction<T, void>; /** Call a callback function on every entry. */ declare function forEachAsync<T>(callback: MaybeAsyncCallbackFunction<T>): AsyncCollectorFunction<T, void>; /** * Groups the source by a key selector. * @param keySelector Key selector function. * @typeParam T Type of items in the source. * @typeParam TKey Type of the key. * @returns Collector that groups the source by a key selector. * * @example * ```typescript * const result = groupBy<number, string>((x) => x % 2 === 0 ? "even" : "odd")([1, 2, 3, 4]); * console.log(result); * // Map { * // 'odd' => [1, 3], * // 'even' => [2, 4], * // } * ``` */ declare function groupBy<T, TKey>(keySelector: (entry: T) => TKey): CollectorFunction<T, Map<TKey, T[]>>; /** Creates a group of entries where the group key is calculated by the selector function. */ declare function groupByAsync<T, TKey>(keySelector: (entry: T) => TKey): AsyncCollectorFunction<T, Map<TKey, T[]>>; /** * Groups the source by a key selector. * @param keySelector Key selector function. * @typeParam T Type of items in the source. * @typeParam TKey Type of the key. * @returns Collector that groups the source by a key selector. * * @example * ```typescript * const result = groupByRecord<number, string>((x) => x % 2 === 0 ? "even" : "odd")([1, 2, 3, 4]); * console.log(result); * // { * // 'odd': [1, 3], * // 'even': [2, 4], * // } * ``` */ declare function groupByRecord<T, TKey extends string | number | symbol>(keySelector: (entry: T) => TKey): CollectorFunction<T, Record<TKey, T[]>>; declare const group: typeof groupByRecord; /** Creates a group of entries where the group key is calculated by the selector function. */ declare function groupByRecordAsync<T, TKey extends string | number | symbol>(keySelector: (entry: T) => TKey): AsyncCollectorFunction<T, Record<TKey, T[]>>; declare const groupAsync: typeof groupByRecordAsync; /** * Determines if the source is empty. * @typeParam T Type of items in the source. * @returns Collector that determines if the source is empty. * * @example * ```typescript * const result = isEmpty<number>()([1, 2, 3]); * console.log(result); // false * ``` */ declare function isEmpty<T>(): CollectorFunction<T, boolean>; /** Returns true if the AsyncIterable has 0 entry. */ declare function isEmptyAsync<T>(): AsyncCollectorFunction<T, boolean>; /** * Joins the source into a string. * @param separator Separator between elements. * @typeParam T Type of items in the source. * @returns Collector that joins the source into a string. * * @example * ```typescript * const result = join<number>()([1, 2, 3]); * console.log(result); // "1,2,3" * ``` */ declare function join<T>(separator?: string): CollectorFunction<T, string>; /** Returns a string of all entries in the Iterable joined together seperated a given string. */ declare function joinAsync<T>(separator?: string): AsyncCollectorFunction<T, string>; /** * Returns the last element in the source that satisfies the predicate. * @param predicate Predicate function to determine if an element should be returned. * @typeParam T Type of items in the source. * @returns Collector that returns the last element in the source that satisfies the predicate. * * @example * ```typescript * const result = last<number>((x) => x > 1)([1, 2, 3]); * console.log(result); // 3 * ``` */ declare function last<T>(predicate?: PredicateFunction<T>): CollectorFunction<T, T | undefined>; declare const findLast: typeof last; /** Returns the last entry from the Iterable that satisfy then 'predicate' function. */ declare function lastAsync<T>(predicate?: MaybeAsyncPredicateFunction<T>): AsyncCollectorFunction<T, T | undefined>; declare const findLastAsync: typeof lastAsync; /** * Returns the index of the last element in the source that satisfies the predicate. * @param predicate Predicate function to determine if an element should be returned. * @typeParam T Type of items in the source. * @returns Collector that returns the index of the last element in the source that satisfies the predicate. * * @example * ```typescript * const result = lastIndex<number>((x) => x > 1)([1, 2, 3]); * console.log(result); // 2 * ``` */ declare function lastIndex<T>(predicate?: PredicateFunction<T>): CollectorFunction<T, number>; declare const findLastIndex: typeof lastIndex; /** Returns the index of the last entry from the Iterable that satisfy then 'predicate' function. */ declare function lastIndexAsync<T>(predicate?: MaybeAsyncPredicateFunction<T>): AsyncCollectorFunction<T, number>; declare const findLastIndexAsync: typeof lastIndexAsync; /** * Returns the last element in the source that satisfies the predicate or a default value if no such element is found. * @param defaultValue Default value to return if no element is found. * @param predicate Predicate function to determine if an element should be returned. * @typeParam T Type of items in the source. * @returns Collector that returns the last element in the source that satisfies the predicate or a default value if no such element is found. * * @example * ```typescript * const result = lastOrDefault<number>(0, (x) => x > 1)([1, 2, 3]); * console.log(result); // 3 * ``` */ declare function lastOrDefault<T>(defaultValue: ValueOrFactory<T>, predicate?: PredicateFunction<T>): CollectorFunction<T, T | undefined>; declare const findLastOrDefault: typeof lastOrDefault; /** Returns the last entry from the Iterable that satisfy then 'predicate' function. */ declare function lastOrDefaultAsync<T>(defaultValue: ValueOrFactory<T>, predicate?: MaybeAsyncPredicateFunction<T>): AsyncCollectorFunction<T, T | undefined>; declare const findLastOrDefaultAsync: typeof lastOrDefaultAsync; /** * Returns the maximum value in a sequence of numbers. * @param numbers Sequence of numbers to find the maximum value. * @returns Maximum value in the sequence. * * @example * ```typescript * const result = max([1, 2, 3]); * console.log(result); // 3 * ``` */ declare const max: CollectorFunction<number, number | undefined>; /** Return the largest value of all entries in the Iterable */ declare const maxAsync: AsyncCollectorFunction<number, number | undefined>; /** * Returns the element in the source that has the maximum value according to the comparer. * @param comparer Comparer function to determine the maximum value. * @typeParam T Type of items in the source. * @returns Collector that returns the element in the source that has the maximum value according to the comparer. * * @example * ```typescript * const result = maxBy<number>((a, b) => a - b)([1, 2, 3]); * console.log(result); // 3 * ``` */ declare function maxBy<T>(comparer: CompareFuncti