sequence-js/src/sync/types.ts

import { AsyncSequence } from "../async/types.js";
import { Collector } from "../collector/types.js";
import { ComparisonOrComparer, Comparer } from "../comparer/types.js";
import { EqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { RandomOptions } from "../random/types.js";
import { AnyPredicate, Converter, TypePredicate, BiConverter, Accumulator, Action } from "../types.js";

export type SequencePipeline<TElement, TResult> = (sequence: Sequence<TElement>) => TResult;
export type SequenceElement<TSequence extends Sequence<any>> = TSequence extends Sequence<infer TElement> ? TElement : never;

export interface Sequence<TElement> extends Iterable<TElement> {
  iterator(): Iterator<TElement>;

  toJSON(): any;

  apply<TResult>(pipeline: SequencePipeline<TElement, TResult>): TResult;

  count(predicate?: AnyPredicate<TElement>): number;
  nonEnumeratedCount(): number;
  fastCount(): number;
  maxCount(): number;

  select<TResult>(selector: Converter<TElement, TResult>): Sequence<TResult>;
  selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>): Sequence<TResult>;

  where<TFiltered extends TElement>(predicate: TypePredicate<TElement, TFiltered>): Sequence<TFiltered>;
  where(predicate: AnyPredicate<TElement>): Sequence<TElement>;

  groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
  groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TKey, TResult>>;

  join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<[TElement, TOther]>;
  join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult>;

  groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
  groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult>;

  contains(obj: TElement, equater?: EqualityComparisonOrComparer<TElement>): boolean;

  sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): boolean;

  append(obj: TElement): Sequence<TElement>;

  prepend(obj: TElement): Sequence<TElement>;

  remove(obj: TElement, all?: boolean, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;

  concat(...sequences: Iterable<TElement>[]): Sequence<TElement>;

  first(predicate?: AnyPredicate<TElement>): TElement;
  firstOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement): TElement | undefined;

  last(predicate?: AnyPredicate<TElement>): TElement;
  lastOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement): TElement | undefined;

  single(predicate?: AnyPredicate<TElement>): TElement;
  singleOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement): TElement | undefined;

  elementAt(index: number): TElement;
  elementAtOrDefault(index: number, def?: TElement): TElement | undefined;

  aggregate(accumulator: Accumulator<TElement, TElement>): TElement;
  aggregate<TAccumulator>(accumulator: Accumulator<TElement, TAccumulator>, seed?: TAccumulator): TAccumulator;
  aggregate<TAccumulator, TResult>(accumulator: Accumulator<TElement, TAccumulator>, seed?: TAccumulator, resultSelector?: Converter<TAccumulator, TResult>): TResult;

  min(comparer?: ComparisonOrComparer<TElement>): TElement;
  minBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): TElement;

  max(comparer?: ComparisonOrComparer<TElement>): TElement;
  maxBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): TElement;

  bounds(comparer?: ComparisonOrComparer<TElement>): [min: TElement, max: TElement];
  boundsBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): [min: TElement, max: TElement];

  order(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement>;
  orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement>;

  orderDescending(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement>;
  orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement>;

  partition(equater?: EqualityComparisonOrComparer<TElement>): Sequence<Sequence<TElement>>;
  partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<Sequence<TElement>>;

  distinct(equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
  distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;

  union(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
  unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;

  except(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
  exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;

  intersect(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
  intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;

  all(predicate: AnyPredicate<TElement>): boolean;
  any(predicate: AnyPredicate<TElement>): boolean;
  any(): boolean;
  none(predicate: AnyPredicate<TElement>): boolean;
  none(): boolean;

  skip(n: number): Sequence<TElement>;
  skipLast(n: number): Sequence<TElement>;
  skipWhile(condition: AnyPredicate<TElement>): Sequence<TElement>;

  take(n: number): Sequence<TElement>;
  takeLast(n: number): Sequence<TElement>;
  takeWhile(condition: AnyPredicate<TElement>): Sequence<TElement>;

  peek(action: Action<TElement>): Sequence<TElement>;

  forEach(action: Action<TElement>): void;

  zip<TOther>(sequence: Iterable<TOther>): Sequence<[TElement, TOther]>;
  cartesianProduct<TOther>(sequence: Iterable<TOther>): Sequence<[TElement, TOther]>;

  indexed(): Sequence<[number, TElement]>;

  reversed(): Sequence<TElement>;

  chunked(size: number): Sequence<Sequence<TElement>>;
  chunked(size: number, asArray: true): Sequence<TElement[]>;
  chunked<TResult>(size: number, transformer: SequencePipeline<TElement, TResult>): Sequence<TResult>;

  random(options?: RandomOptions<TElement>): TElement | undefined;

  cached(): Sequence<TElement>;

  awaited(): AsyncSequence<Awaited<TElement>>;

  asArray(): TElement[];
  toArray(): TElement[];
  toMap<TKey>(keySelector: Converter<TElement, TKey>): Map<TKey, TElement>;
  toMap<TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Map<TKey, TValue>;
  toSet(): Set<TElement>;
  toObject<TKey extends PropertyKey>(keySelector: Converter<TElement, TKey>): Record<TKey, TElement>;
  toObject<TKey extends PropertyKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Record<TKey, TValue>;

  collect<TResult>(collector: Collector<TElement, any, TResult>): TResult;
}

export interface GroupedSequence<TKey, TElement> extends Sequence<TElement> {
  get key(): TKey;
}

export interface OrderedSequence<TElement> extends Sequence<TElement> {
  get comparer(): Comparer<TElement>;

  thenSelf(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement>;

  thenBy<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement>;

  thenSelfDescending(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement>;

  thenByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement>;
}