Merge pull request #2 from danielrbradley/next-modules

Add next modules

src/arrays.ts

@@ -0,0 +1,326 @@
+export function ofIterable<T>(source: Iterable<T>): T[] {
+ return Array.from(source)
+}
+
+export function map<T, U>(mapping: (item: T) => U): (source: T[]) => U[]
+export function map<T, U>(source: T[], mapping: (item: T) => U): U[]
+export function map<T, U>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const mapping: (item: T) => U = partial ? a : b
+ function exec(source: T[]) {
+ return source.map(mapping)
+ }
+ return partial ? exec : exec(a)
+}
+
+export function filter<T>(predicate: (item: T) => boolean): (source: T[]) => T[]
+export function filter<T>(source: T[], predicate: (item: T) => boolean): T[]
+export function filter<T, U>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const predicate: (item: T) => boolean = partial ? a : b
+ function exec(source: T[]) {
+ return source.filter(predicate)
+ }
+ return partial ? exec : exec(a)
+}
+
+export function choose<T, U>(chooser: (item: T) => U | undefined): (source: T[]) => U[]
+export function choose<T, U>(source: T[], chooser: (item: T) => U | undefined): U[]
+export function choose<T, U>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const chooser: (item: T) => U | undefined = partial ? a : b
+ function exec(source: T[]) {
+ const target = []
+ for (const item of source) {
+ const chosen = chooser(item)
+ if (chosen !== undefined) {
+ target.push(chosen)
+ }
+ }
+ return target
+ }
+ return partial ? exec : exec(a)
+}
+
+export function collect<T, U>(mapping: (item: T) => U[]): (source: T[]) => U[]
+export function collect<T, U>(source: T[], mapping: (item: T) => U[]): U[]
+export function collect<T, U>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const mapping: (item: T) => U[] = partial ? a : b
+ function exec(source: T[]) {
+ const target = []
+ for (const item of source) {
+ const children = mapping(item)
+ for (const child of children) {
+ target.push(child)
+ }
+ }
+ return target
+ }
+ return partial ? exec : exec(a)
+}
+
+export function append<T>(second: T[]): (first: T[]) => T[]
+export function append<T>(first: T[], second: T[]): T[]
+export function append<T>(a: any, b?: any): any {
+ const partial = b === undefined
+ const second: T[] = partial ? a : b
+ function exec(first: T[]): T[] {
+ return ([] as T[]).concat(first).concat(second)
+ }
+ return partial ? exec : exec(a)
+}
+
+export function concat<T>(sources: T[][]): T[] {
+ const target = []
+ for (const source of sources) {
+ for (const item of source) {
+ target.push(item)
+ }
+ }
+ return target
+}
+
+export function distinctBy<T, Key>(selector: (item: T) => Key): (source: T[]) => T[]
+export function distinctBy<T, Key>(source: T[], selector: (item: T) => Key): T[]
+export function distinctBy<T, Key>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const selector: (item: T) => Key = partial ? a : b
+ function exec(source: T[]): T[] {
+ const seen = new Map<Key, T>()
+ for (const item of source) {
+ const key = selector(item)
+ if (!seen.has(key)) {
+ seen.set(key, item)
+ }
+ }
+ return Array.from(seen.values())
+ }
+ return partial ? exec : exec(a)
+}
+
+export function exists<T>(predicate: (item: T) => boolean): (source: T[]) => boolean
+export function exists<T>(source: T[], predicate: (item: T) => boolean): boolean
+export function exists<T>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const predicate: (item: T) => boolean = partial ? a : b
+ function exec(source: T[]): boolean {
+ return source.some(predicate)
+ }
+ return partial ? exec : exec(a)
+}
+
+export function get<T>(predicate: (item: T) => boolean): (source: T[]) => T
+export function get<T>(source: T[], predicate: (item: T) => boolean): T
+export function get<T>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const predicate: (item: T) => boolean = partial ? a : b
+ function exec(source: T[]): T | undefined {
+ for (const item of source) {
+ if (predicate(item)) {
+ return item
+ }
+ }
+ throw new Error('Element not found matching criteria')
+ }
+ return partial ? exec : exec(a)
+}
+
+export function find<T>(predicate: (item: T) => boolean): (source: T[]) => T | undefined
+export function find<T>(source: T[], predicate: (item: T) => boolean): T | undefined
+export function find<T>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const predicate: (item: T) => boolean = partial ? a : b
+ function exec(source: T[]): T | undefined {
+ for (const item of source) {
+ if (predicate(item)) {
+ return item
+ }
+ }
+ return undefined
+ }
+ return partial ? exec : exec(a)
+}
+
+export function groupBy<T, Key>(selector: (item: T) => Key): (source: T[]) => [Key, T[]][]
+export function groupBy<T, Key>(source: T[], selector: (item: T) => Key): [Key, T[]][]
+export function groupBy<T, Key>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const selector: (item: T) => Key = partial ? a : b
+ function exec(source: T[]): [Key, T[]][] {
+ const groups = new Map<Key, T[]>()
+ for (const item of source) {
+ const key = selector(item)
+ const group = groups.get(key)
+ if (group === undefined) {
+ groups.set(key, [item])
+ } else {
+ group.push(item)
+ }
+ }
+ return Array.from(groups.entries())
+ }
+ return partial ? exec : exec(a)
+}
+
+export interface InitRange {
+ from: number
+ to: number
+ increment?: number
+}
+
+export interface InitCount {
+ start?: number
+ count: number
+ increment?: number
+}
+
+export function init(options: number | InitRange | InitCount): number[]
+export function init<T>(
+ options: number | InitRange | InitCount,
+ initializer: (index: number) => T
+): T[]
+export function init<T>(
+ options: number | InitRange | InitCount,
+ initializer?: (index: number) => T
+): any[] {
+ function normaliseOptions() {
+ if (typeof options === 'number') {
+ return {
+ start: 0,
+ count: options,
+ increment: 1
+ }
+ }
+ if ('from' in options) {
+ const sign = options.to < options.from ? -1 : 1
+ if (
+ options.increment !== undefined &&
+ (options.increment === 0 || options.increment / sign < 0)
+ ) {
+ throw new Error('Requested array is of infinite size.')
+ }
+ const increment = options.increment ? options.increment : sign
+ return {
+ start: options.from,
+ count: (options.to - options.from) / increment + 1,
+ increment: increment
+ }
+ }
+ const start = options.start === undefined ? 0 : options.start
+ return {
+ start,
+ count: options.count,
+ increment: options.increment === undefined ? 1 : options.increment
+ }
+ }
+ const { start, count, increment } = normaliseOptions()
+ const map = initializer === undefined ? (x: number) => x : initializer
+ const target = []
+ let current = start
+ for (let index = 0; index < count; index++) {
+ target.push(map(current))
+ current += increment
+ }
+ return target
+}
+
+export function length<T>(source: T[]): number {
+ return source.length
+}
+
+function compareBy<T>(getProp: (item: T) => any) {
+ return (a: T, b: T) => {
+ return getProp(a) > getProp(b) ? 1 : -1
+ }
+}
+
+export function sortBy<T, Key>(selector: (item: T) => Key): (source: T[]) => T[]
+export function sortBy<T, Key>(source: T[], selector: (item: T) => Key): T[]
+export function sortBy<T, Key>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const selector: (item: T) => Key = partial ? a : b
+ function exec(source: T[]): T[] {
+ const copy = Array.from(source)
+ copy.sort(compareBy(selector))
+ return copy
+ }
+ return partial ? exec : exec(a)
+}
+
+export function sumBy<T>(selector: (item: T) => number): (source: T[]) => number
+export function sumBy<T>(source: T[], selector: (item: T) => number): number
+export function sumBy<T>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const selector: (item: T) => number = partial ? a : b
+ function exec(source: T[]): number {
+ let sum = 0
+ for (const item of source) {
+ sum += selector(item)
+ }
+ return sum
+ }
+ return partial ? exec : exec(a)
+}
+
+export function maxBy<T>(selector: (item: T) => number): (source: T[]) => number
+export function maxBy<T>(source: T[], selector: (item: T) => number): number
+export function maxBy<T>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const selector: (item: T) => number = partial ? a : b
+ function exec(source: T[]): number {
+ let max: number | null = null
+ for (const item of source) {
+ const value = selector(item)
+ if (max === null || value > max) {
+ max = value
+ }
+ }
+ if (max === null) {
+ throw new Error(`Can't find max of an empty array`)
+ }
+ return max
+ }
+ return partial ? exec : exec(a)
+}
+
+export function minBy<T>(selector: (item: T) => number): (source: T[]) => number
+export function minBy<T>(source: T[], selector: (item: T) => number): number
+export function minBy<T>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const selector: (item: T) => number = partial ? a : b
+ function exec(source: T[]): number {
+ let min: number | null = null
+ for (const item of source) {
+ const value = selector(item)
+ if (min === null || value < min) {
+ min = value
+ }
+ }
+ if (min === null) {
+ throw new Error(`Can't find min of an empty array`)
+ }
+ return min
+ }
+ return partial ? exec : exec(a)
+}
+
+export function meanBy<T>(selector: (item: T) => number): (source: T[]) => number
+export function meanBy<T>(source: T[], selector: (item: T) => number): number
+export function meanBy<T>(a: any, b?: any): any {
+ const partial = typeof a === 'function'
+ const selector: (item: T) => number = partial ? a : b
+ function exec(source: T[]): number {
+ let sum = 0
+ let count = 0
+ for (const item of source) {
+ sum += selector(item)
+ count++
+ }
+ if (count === 0) {
+ throw new Error(`Can't find mean of an empty array`)
+ }
+ return sum / count
+ }
+ return partial ? exec : exec(a)
+}

src/collection-fns.ts

@@ -1,4 +1,10 @@
 import * as iterables from './iterables'
+import * as arrays from './arrays'
+import * as sets from './sets'
+import * as maps from './maps'
 export * from './pipes'
 
 export const Iterables = iterables
+export const Arrays = arrays
+export const Sets = sets
+export const Maps = maps