150 lines
9.5 KiB
TypeScript
150 lines
9.5 KiB
TypeScript
import { Collector } from "../collector/types.js";
|
|
import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "../comparer/types.js";
|
|
import { MaybeAsyncEqualityComparison } from "../equality-comparer/types.js";
|
|
import { AsyncRandomOptions } from "../random/types.js";
|
|
import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncAction, MaybeAsyncFunction, MaybePromise, MaybeAsyncIterable } from "../types.js";
|
|
|
|
export type AsyncSequencePipeline<TElement, TResult> = MaybeAsyncFunction<(sequence: AsyncSequence<TElement>) => TResult>;
|
|
|
|
export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
|
|
iterator(): AsyncIterator<TElement>;
|
|
|
|
apply<TResult>(pipeline: AsyncSequencePipeline<TElement, TResult>): MaybePromise<TResult>;
|
|
|
|
count(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<number>;
|
|
nonEnumeratedCount(): Promise<number>;
|
|
fastCount(): Promise<number>;
|
|
maxCount(): Promise<number>;
|
|
|
|
select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult>;
|
|
selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult>;
|
|
|
|
where<TFiltered extends TElement>(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TFiltered>;
|
|
where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
|
|
|
|
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
|
|
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
|
|
|
|
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<[TElement, TOther]>;
|
|
join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<TResult>;
|
|
|
|
groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
|
|
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<TResult>;
|
|
|
|
contains(obj: TElement, equater?: MaybeAsyncEqualityComparison<TElement>): Promise<boolean>;
|
|
|
|
sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): Promise<boolean>;
|
|
|
|
append(obj: TElement): AsyncSequence<TElement>;
|
|
|
|
prepend(obj: TElement): AsyncSequence<TElement>;
|
|
|
|
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
|
|
|
|
concat(...sequences: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>;
|
|
|
|
first(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<TElement>;
|
|
firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
|
|
|
|
last(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<TElement>;
|
|
lastOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
|
|
|
|
single(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<TElement>;
|
|
singleOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
|
|
|
|
elementAt(index: number): Promise<TElement>;
|
|
elementAtOrDefault(index: number, def?: TElement): Promise<TElement | undefined>;
|
|
|
|
aggregate(accumulator: MaybeAsyncAccumulator<TElement, TElement>): Promise<TElement>;
|
|
aggregate<TAccumulator>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator): Promise<TAccumulator>;
|
|
aggregate<TAccumulator, TResult>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator, resultSelector?: MaybeAsyncConverter<TAccumulator, TResult>): Promise<TResult>;
|
|
|
|
min(): Promise<TElement>;
|
|
minBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement>;
|
|
|
|
max(): Promise<TElement>;
|
|
maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement>;
|
|
|
|
bounds(comparer?: MaybeAsyncComparisonOrComparer<TElement>): Promise<[min: TElement, max: TElement]>;
|
|
boundsBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): Promise<[min: TElement, max: TElement]>;
|
|
|
|
order(comparer?: MaybeAsyncComparisonOrComparer<TElement>): AsyncSequence<TElement>;
|
|
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): AsyncSequence<TElement>;
|
|
|
|
orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): AsyncSequence<TElement>;
|
|
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): AsyncSequence<TElement>;
|
|
|
|
partition(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<AsyncSequence<TElement>>;
|
|
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<AsyncSequence<TElement>>;
|
|
|
|
distinct(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
|
|
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
|
|
|
|
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
|
|
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
|
|
|
|
except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
|
|
exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
|
|
|
|
intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
|
|
intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
|
|
|
|
all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
|
|
any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
|
|
any(): Promise<boolean>;
|
|
none(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
|
|
none(): Promise<boolean>;
|
|
|
|
skip(n: number): AsyncSequence<TElement>;
|
|
skipLast(n: number): AsyncSequence<TElement>;
|
|
skipWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
|
|
|
|
take(n: number): AsyncSequence<TElement>;
|
|
takeLast(n: number): AsyncSequence<TElement>;
|
|
takeWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
|
|
|
|
peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement>;
|
|
|
|
forEach(action: MaybeAsyncAction<TElement>): Promise<void>;
|
|
|
|
zip<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]>;
|
|
|
|
indexed(): AsyncSequence<[number, TElement]>;
|
|
|
|
reversed(): AsyncSequence<TElement>;
|
|
|
|
chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
|
|
chunked<TResult>(size: number, transformer: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<TResult>;
|
|
|
|
random(options?: AsyncRandomOptions<TElement>): Promise<TElement | undefined>;
|
|
|
|
cached(): AsyncSequence<TElement>;
|
|
|
|
asArray(): Promise<TElement[]>;
|
|
|
|
toArray(): Promise<TElement[]>;
|
|
toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Map<TKey, TElement>>;
|
|
toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
|
|
toSet(): Promise<Set<TElement>>;
|
|
toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Record<TKey, TElement>>;
|
|
toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;
|
|
|
|
collect<TResult>(collector: Collector<TElement, any, TResult>): Promise<TResult>;
|
|
}
|
|
|
|
export interface GroupedAsyncSequence<TKey, TElement> extends AsyncSequence<TElement> {
|
|
get key(): TKey;
|
|
}
|
|
|
|
export interface OrderedAsyncSequence<TElement> extends AsyncSequence<TElement> {
|
|
get comparer(): AsyncComparer<TElement>;
|
|
|
|
thenSelf(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement>;
|
|
|
|
thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement>;
|
|
|
|
thenSelfDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement>;
|
|
|
|
thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement>;
|
|
}
|