std-collection.d.ts

type Predicate<T> = (item: T) => boolean
type Selector<T, O = unknown> = (item: T) => O
type Grouping<V> = Record<string, Array<V>>

// 6 Array predicates
// 19 Array transformations to Array
// 14 Array transformations to value
// 9 Array transformations to other formats
// 2 Record Predicates
// 9 Record Transformations to Records
// 3 Group APIs

// 61 APIs.

// Array predicates (6)
declare function none<T>(collection: Array<T>, predicate: Predicate<T>): boolean
declare function includesAll<T, O extends T>(collection: Array<T>, needles: Array<O>): boolean
declare function includesAny<T, O extends T>(collection: Array<T>, needles: Array<O>): boolean
declare function includesNone<T, O extends T>(collection: Array<T>, needles: Array<O>): boolean
declare function isEmpty(collection: Array<unknown>): boolean
declare function isNotEmpty(collection: Array<unknown>): boolean

// Array transformations to Array (19)
declare function mapNotNullish<T, O>(collection: Array<T>, transformer: Selector<T, O>): Array<NonNullable<O>>
declare function takeFirst<T>(collection: Array<T>, n: number): Array<T>
declare function takeLast<T>(collection: Array<T>, n: number): Array<T>
declare function dropFirst<T>(collection: Array<T>, n: number): Array<T>
declare function dropLast<T>(collection: Array<T>, n: number): Array<T>
declare function takeFirstWhile<T>(collection: Array<T>, predicate: Predicate<T>): Array<T>
declare function takeLastWhile<T>(collection: Array<T>, predicate: Predicate<T>): Array<T>
declare function dropFirstWhile<T>(collection: Array<T>, predicate: Predicate<T>): Array<T>
declare function dropLastWhile<T>(collection: Array<T>, predicate: Predicate<T>): Array<T>
declare function filterNot<T>(collection: Array<T>, predicate: Predicate<T>): Array<T>
declare function filterNotNullish<T>(collection: Array<T>): Array<NonNullable<T>>
declare function distinct<T>(collection: Array<T>): Array<T>
declare function distinctBy<T>(collection: Array<T>, selector: Selector<T>): Array<T>
declare function sortBy<T>(collection: Array<T>, selector: Selector<T, number | string>): Array<T>
declare function intersect<T>(collection: Array<T>, withCollection: Array<T>): Array<T>
declare function union<T>(collection: Array<T>, withCollection: Array<T>): Array<T>
declare function runningReduce<T, A>(collection: Array<T>, reducer: (accumulator: A, current: T) => A, initialValue: A): Array<A>
declare function without<T>(collection: Array<T>, toRemove: T): Array<T>
declare function withoutAll<T>(collection: Array<T>, toRemove: Array<T>): Array<T>

// Array transformations to value (14)
declare function lastIndex(collection: Array<unknown>): number
declare function first<T>(collection: Array<T>): T | undefined
declare function last<T>(collection: Array<T>): T | undefined
declare function findLast<T>(collection: Array<T>, predicate: Predicate<T>): T | undefined
declare function single<T>(collection: Array<T>, predicate: Predicate<T>): T | undefined
declare function firstNotNullishOf<T, O>(collection: Array<T>, selector: Selector<T, O>): NonNullable<O> | undefined
declare function sumOf<T>(collection: Array<T>, selector: Selector<T, number>): number
declare function maxBy<T>(collection: Array<T>, selector: Selector<T, number | string>): T | undefined
declare function minBy<T>(collection: Array<T>, selector: Selector<T, number | string>): T | undefined
declare function maxWith<T>(collection: Array<T>, comparator: (a: T, b: T) => number): T | undefined
declare function minWith<T>(collection: Array<T>, comparator: (a: T, b: T) => number): T | undefined
declare function maxOf<T, O extends number | string>(collection: Array<T>, selector: Selector<T, O>): O | undefined
declare function minOf<T, O extends number | string>(collection: Array<T>, selector: Selector<T, O>): O | undefined
declare function average(collection: Array<number>): number | undefined

// Array transformations to other formats (8)
declare function zip<T, U>(collection: Array<T>, withCollection: Array<U>): Array<[ T, U ]>
declare function unzip<T, U>(pairs: Array<[ T, U ]>): [ Array<T>, Array<U> ]
declare function associateBy<T>(collection: Array<T>, selector: Selector<T, string>): Record<string, T>
declare function groupBy<T>(collection: Array<T>, selector: Selector<T, string>): Grouping<T>
declare function partition<T>(collection: Array<T>, predicate: Predicate<T>): [ Array<T>, Array<T> ]
declare function chunked<T>(collection: Array<T>, size: number): Array<Array<T>>
declare function permutations<T>(collection: Array<T>, size?: number): Array<Array<T>>
declare function windowed<T>(collection: Array<T>, size: number, config?: { step?: number, partial?: boolean }): Array<Array<T>>

// Record Predicates (2)
declare function includesValue<T>(collection: Record<string, T>, value: T): boolean
declare function includesKey<T>(collection: Record<string, T>, value: string): boolean

// Record Transformations to Records (9)
declare function filterEntries<T>(collection: Record<string, T>, predicate: Predicate<[string, T]>): Record<string, T>
declare function filterKeys<T>(collection: Record<string, T>, predicate: Predicate<string>): Record<string, T>
declare function filterValues<T>(collection: Record<string, T>, predicate: Predicate<T>): Record<string, T>
declare function filterValuesNotNullish<T>(collection: Record<string, T>): Record<string, NonNullable<T>>
declare function mapEntries<T, O>(collection: Record<string, T>, transformer: Selector<[string, T], [string, O]>): Record<string, O>
declare function deepMerge<T extends Record<keyof any, unknown>>(collection: Partial<T>, other: Partial<T>): T
declare function deepMerge<T extends Record<keyof any, unknown>, U extends Record<keyof unknown, unknown>>(collection: T, other: U): T & U
declare function mapKeys<T>(collection: Record<string, T>, transformer: Selector<string, string>): Record<string, T>
declare function mapValues<T, O>(collection: Record<string, T>, transformer: Selector<T, O>): Record<string, O>

// Groups (3)
declare function countGroups(collection: Grouping<unknown>): Record<string, number>
declare function reduceGroups<T, A>(collection: Grouping<T>, reducer: (accumulator: A, current: T) => A, initialValue: A): Record<string, A>
declare function aggregateGroups<T, A>(collection: Grouping<T>, aggregator: (accumulator: A, current: T, key: string, first: boolean) => A, initalValue: A): Record<string, A>