curray/dist/index.mjs.map

Curray is an extension library for the native JavaScript Array object.

{"version":3,"file":"index.mjs","sources":["../src/helpers.ts","../src/index.ts"],"sourcesContent":["/**\n * Check if the given argument is an object\n * @param x argument\n */\nexport const isObj = <T>(x: T): boolean => !!x && typeof x === 'object';\n\n/**\n * Creates a function that negates the result of the predicate\n */\nexport const negate =\n  <T>(predicate: (value: T, index?: number, list?: T[]) => boolean) =>\n  (value: T, index?: number, list?: T[]) =>\n    !predicate(value, index, list);\n\nexport const composeComparers =\n  <T>(\n    previousComparer: (a: T, b: T) => number,\n    currentComparer: (a: T, b: T) => number,\n  ): ((a: T, b: T) => number) =>\n  (a: T, b: T) =>\n    previousComparer(a, b) || currentComparer(a, b);\n\nexport const keyComparer =\n  <T, TKey>(\n    keySelector: (key: T) => TKey,\n    descending: boolean = false,\n  ): ((a: T, b: T) => number) =>\n  (a: T, b: T) => {\n    const sortKeyA = keySelector(a);\n    const sortKeyB = keySelector(b);\n    if (sortKeyA > sortKeyB) {\n      return !descending ? 1 : -1;\n    } else if (sortKeyA < sortKeyB) {\n      return !descending ? -1 : 1;\n    } else {\n      return 0;\n    }\n  };\n\n/**\n * Represents a sorted sequence. The methods of this class are implemented by using deferred execution.\n * The immediate return value is an object that stores all the information that is required to perform the action.\n * The query represented by this method is not executed until the object is enumerated either by\n * calling its ToDictionary, ToLookup, ToList or ToArray methods\n */\nexport class OrderedArray<T, TKey> extends Array<T> {\n  static get [Symbol.species]() {\n    return Array;\n  }\n\n  /* istanbul ignore next */\n  constructor(\n    elements: T[],\n    private readonly _comparer: (a: T, b: T) => number,\n  ) {\n    super(...elements);\n    Object.setPrototypeOf(this, OrderedArray.prototype);\n    this.sort(this._comparer);\n  }\n\n  /**\n   * Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.\n   * @override\n   */\n  thenBy(keySelector: (key: T) => number | string): OrderedArray<T, TKey> {\n    return new OrderedArray(\n      this,\n      composeComparers(this._comparer, keyComparer(keySelector, false)),\n    );\n  }\n\n  /**\n   * Performs a subsequent ordering of the elements in a sequence in descending order, according to a key.\n   * @override\n   */\n  thenByDescending(\n    keySelector: (key: T) => number | string,\n  ): OrderedArray<T, TKey> {\n    return new OrderedArray(\n      this,\n      composeComparers(this._comparer, keyComparer(keySelector, true)),\n    );\n  }\n}\n","import { keyComparer, negate, OrderedArray } from './helpers';\n\ndeclare global {\n  export interface Array<T> {\n    addRange<T>(elements: T[]): void;\n    aggregate<U, R>(\n      accumulator: (accum: U, value?: T, index?: number, list?: T[]) => R,\n      initialValue?: U,\n    ): R;\n    all(predicate: (value: T, index?: number, list?: T[]) => boolean): boolean;\n    any(): boolean;\n    any(predicate: (value: T, index?: number, list?: T[]) => boolean): boolean;\n    any(\n      predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n    ): boolean;\n    average(): number;\n    average(\n      transform: (value: T, index?: number, list?: T[]) => number,\n    ): number;\n    average(\n      transform?: (value?: T, index?: number, list?: T[]) => number,\n    ): number;\n    cast<U>(): U[];\n    contains(element: T): boolean;\n    count(): number;\n    count(predicate: (value: T, index?: number, list?: T[]) => boolean): number;\n    count(\n      predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n    ): number;\n    defaultIfEmpty(defaultValue?: T): T[];\n    distinctBy(keySelector: (key: T) => string | number): T[];\n    elementAt(index: number): T;\n    elementAtOrDefault(index: number): T | null;\n    except(source: T[]): T[];\n    first(): T;\n    first(predicate: (value: T, index?: number, list?: T[]) => boolean): T;\n    first(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T;\n    firstOrDefault(): T | null;\n    firstOrDefault(\n      predicate: (value: T, index?: number, list?: T[]) => boolean,\n    ): T | null;\n    firstOrDefault(\n      predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n    ): T | null;\n    groupBy<TResult = T>(\n      grouper: (key: T) => string | number,\n      mapper?: (element: T) => TResult,\n    ): { [key: string]: TResult[] };\n    groupJoin<U, TKey, TResult>(\n      list: U[],\n      key1: (k: T) => TKey,\n      key2: (k: U) => TKey,\n      result: (first: T, second: U[]) => TResult,\n    ): TResult[];\n    indexOf(element: T): number;\n    insert(index: number, element: T): void | Error;\n    intersect(source: T[]): T[];\n    last(): T;\n    last(predicate: (value: T, index?: number, list?: T[]) => boolean): T;\n    last(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T;\n    lastOrDefault(): T | null;\n    lastOrDefault(\n      predicate: (value: T, index?: number, list?: T[]) => boolean,\n    ): T | null;\n    lastOrDefault(\n      predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n    ): T | null;\n    max(): number;\n    max(selector: (value: T, index?: number, array?: T[]) => number): number;\n    max(selector?: (value?: T, index?: number, array?: T[]) => number): number;\n    min(): number;\n    min(selector: (value: T, index?: number, array?: T[]) => number): number;\n    min(selector?: (value?: T, index?: number, array?: T[]) => number): number;\n    ofType<U>(type: unknown): U[];\n    orderBy<TKey>(keySelector: (key: T) => TKey): OrderedArray<T, TKey>;\n    orderByDescending<TKey>(\n      keySelector: (key: T) => TKey,\n    ): OrderedArray<T, TKey>;\n    removeAll(\n      predicate: (value: T, index?: number, list?: T[]) => boolean,\n    ): T[];\n    select<TOut>(selector: (element: T, index: number) => TOut): TOut[];\n    selectMany<TResult>(\n      selector: (element: T, index: number) => TResult[],\n    ): TResult[];\n    sequenceEqual(list: T[]): boolean;\n    single(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T;\n    singleOrDefault(\n      predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n    ): T | null;\n    skip(amount: number): T[];\n    skipWhile(\n      predicate: (value: T, index?: number, list?: T[]) => boolean,\n    ): T[];\n    sum(): number;\n    sum(transform: (value: T, index?: number, list?: T[]) => number): number;\n    sum(transform?: (value?: T, index?: number, list?: T[]) => number): number;\n    take(amount: number): T[];\n    takeWhile(\n      predicate: (value: T, index?: number, list?: T[]) => boolean,\n    ): T[];\n    union(list: T[]): T[];\n    where(predicate: (value: T, index?: number, list?: T[]) => boolean): T[];\n    zip<U, T, TOut>(list: U[], result: (first: T, second: U) => TOut): TOut[];\n  }\n}\n\n/**\n * Adds the elements of the specified collection to the end of the List<T>.\n */\nArray.prototype.addRange = function <T>(elements: T[]): void {\n  this.push(...elements);\n};\n\n/**\n * Applies an accumulator function over a sequence.\n */\nArray.prototype.aggregate = function <U, T, R>(\n  accumulator: (accum: U, value?: T, index?: number, list?: T[]) => R,\n  initialValue?: U,\n): R {\n  return this.reduce(accumulator, initialValue);\n};\n\n/**\n * Determines whether all elements of a sequence satisfy a condition.\n */\nArray.prototype.all = function <T>(\n  predicate: (value: T, index?: number, list?: T[]) => boolean,\n): boolean {\n  return this.every(predicate);\n};\n\n/**\n * Determines whether a sequence contains any elements.\n */\nArray.prototype.any = function <T>(\n  predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n): boolean {\n  return predicate ? this.some(predicate) : this.length > 0;\n};\n\n/**\n * Computes the average of a sequence of number values that are obtained by invoking\n * a transform function on each element of the input sequence.\n */\nArray.prototype.average = function <T>(\n  transform?: (value?: T, index?: number, list?: T[]) => number,\n): number {\n  return this.sum(transform) / this.length;\n};\n\n/**\n * Casts the elements of a sequence to the specified type.\n */\nArray.prototype.cast = function <T>() {\n  return this as T[];\n};\n\n/**\n * Determines whether an element is in the Array<T>.\n */\nArray.prototype.contains = function <T>(element: T): boolean {\n  return this.some((x: T) => x === element);\n};\n\n/**\n * Returns the number of elements in a sequence.\n */\nArray.prototype.count = function <T>(\n  predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n): number {\n  return predicate ? this.where(predicate).count() : this.length;\n};\n\n/**\n * Returns the elements of the specified sequence or the type parameter's default value\n * in a singleton collection if the sequence is empty.\n */\nArray.prototype.defaultIfEmpty = function <T>(defaultValue?: T): T[] {\n  return this.count() ? this : [defaultValue];\n};\n\n/**\n * Returns distinct elements from a sequence according to specified key selector.\n */\nArray.prototype.distinctBy = function <T>(\n  keySelector: (key: T) => string | number,\n): T[] {\n  const groups = this.groupBy(keySelector);\n  return Object.keys(groups).reduce((res, key) => {\n    const group = groups[key];\n    if (group != null && group.length > 0) {\n      res.push(group[0]);\n    }\n    return res;\n  }, new Array<T>());\n};\n\n/**\n * Returns the element at a specified index in a sequence.\n */\nArray.prototype.elementAt = function <T>(index: number): T {\n  if (index < this.count() && index >= 0) {\n    return this[index];\n  } else {\n    throw new Error(\n      'ArgumentOutOfRangeException: index is less than 0 or greater than or equal to the number of elements in source.',\n    );\n  }\n};\n\n/**\n * Returns the element at a specified index in a sequence or a default value if the index is out of range.\n */\nArray.prototype.elementAtOrDefault = function <T>(index: number): T | null {\n  return this.elementAt(index) !== undefined && this.elementAt(index);\n};\n\n/**\n * Produces the set difference of two sequences by using the default equality comparer to compare values.\n */\nArray.prototype.except = function <T>(source: T[]): T[] {\n  return this.where((x: T) => !source.contains(x));\n};\n\n/**\n * Returns the first element of a sequence.\n */\nArray.prototype.first = function <T>(\n  predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n): T {\n  if (this.count()) {\n    return predicate ? this.where(predicate).first() : this[0];\n  } else {\n    throw new Error('InvalidOperationException: The source sequence is empty.');\n  }\n};\n\n/**\n * Returns the first element of a sequence, or a default value if the sequence contains no elements.\n */\nArray.prototype.firstOrDefault = function <T>(\n  predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n): T | null {\n  return this.count(predicate) ? this.first(predicate) : null;\n};\n\n/**\n * Groups the elements of a sequence according to a specified key selector function.\n */\nArray.prototype.groupBy = function <T, TResult>(\n  grouper: (key: T) => string | number,\n  mapper?: (element: T) => TResult,\n): { [key: string]: TResult[] } {\n  const initialValue: { [key: string]: TResult[] } = {};\n  const thisMapper = mapper ?? ((val) => val as unknown as TResult);\n  return this.aggregate((ac: { [x: string]: TResult[] }, v: T) => {\n    const key = grouper(v);\n    const existingGroup = ac[key];\n    const mappedValue = thisMapper(v);\n    if (existingGroup) {\n      existingGroup.push(mappedValue);\n    } else {\n      ac[key] = [mappedValue];\n    }\n    return ac;\n  }, initialValue);\n};\n\n/**\n * Correlates the elements of two sequences based on equality of keys and groups the results.\n * The default equality comparer is used to compare keys.\n */\nArray.prototype.groupJoin = function <T, U, TKey, TResult>(\n  list: U[],\n  key1: (k: T) => TKey,\n  key2: (k: U) => TKey,\n  result: (first: T, second: U[]) => TResult,\n): TResult[] {\n  return this.select((x: T) =>\n    result(\n      x,\n      list.where((z) => key1(x) === key2(z)),\n    ),\n  );\n};\n\n/**\n * Produces the set intersection of two sequences by using the default equality comparer to compare values.\n */\nArray.prototype.intersect = function <T>(source: T[]): T[] {\n  return this.where((x: T) => source.contains(x));\n};\n\n/**\n * Returns the last element of a sequence.\n */\nArray.prototype.last = function <T>(\n  predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n): T {\n  if (this.count()) {\n    return predicate ? this.where(predicate).last() : this[this.count() - 1];\n  } else {\n    throw Error('InvalidOperationException: The source sequence is empty.');\n  }\n};\n\n/**\n * Returns the last element of a sequence, or a default value if the sequence contains no elements.\n */\nArray.prototype.lastOrDefault = function <T>(\n  predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n): T | null {\n  return this.count(predicate) ? this.last(predicate) : null;\n};\n\n/**\n * Returns the maximum value in a generic sequence.\n */\nArray.prototype.max = function <T>(\n  selector?: (value: T, index: number, array: T[]) => number,\n): number {\n  const id = (x: number) => x;\n  return Math.max(...this.map(selector || id));\n};\n\n/**\n * Returns the minimum value in a generic sequence.\n */\nArray.prototype.min = function <T>(\n  selector?: (value: T, index: number, array: T[]) => number,\n): number {\n  const id = (x: number) => x;\n  return Math.min(...this.map(selector || id));\n};\n\n/**\n * Filters the elements of a sequence based on a specified type.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nArray.prototype.ofType = function <U>(type: any): U[] {\n  let typeName: string | null;\n  switch (type) {\n    case Number:\n      typeName = 'number';\n      break;\n    case String:\n      typeName = 'string';\n      break;\n    case Boolean:\n      typeName = 'boolean';\n      break;\n    case Function:\n      typeName = 'function';\n      break;\n    default:\n      typeName = null;\n      break;\n  }\n  return typeName === null\n    ? (this.where((x) => x instanceof type) as U[]).cast<U>()\n    : (this.where((x) => typeof x === typeName) as U[]).cast<U>();\n};\n\n/**\n * Sorts the elements of a sequence in ascending order according to a key.\n */\nArray.prototype.orderBy = function <T, TKey>(\n  keySelector: (key: T) => TKey,\n): OrderedArray<T, TKey> {\n  return new OrderedArray(this, keyComparer(keySelector, false));\n};\n\n/**\n * Sorts the elements of a sequence in descending order according to a key.\n */\nArray.prototype.orderByDescending = function <T, TKey>(\n  keySelector: (key: T) => TKey,\n): OrderedArray<T, TKey> {\n  return new OrderedArray(this, keyComparer(keySelector, true));\n};\n\n/**\n * Removes all the elements that match the conditions defined by the specified predicate.\n */\nArray.prototype.removeAll = function <T>(\n  predicate: (value: T, index?: number, list?: T[]) => boolean,\n): T[] {\n  return this.where(negate(predicate));\n};\n\n/**\n * Projects each element of a sequence into a new form.\n */\nArray.prototype.select = function <T, TOut>(\n  selector: (element: T, index: number) => TOut,\n): TOut[] {\n  return this.map(selector);\n};\n\n/**\n * Projects each element of a sequence to a Array<any> and flattens the resulting sequences into one sequence.\n */\nArray.prototype.selectMany = function <T, TResult>(\n  selector: (element: T, index: number) => TResult[],\n): TResult[] {\n  return this.reduce(\n    (acc, element, index) => acc.concat(selector(element, index)),\n    [] as TResult[],\n  );\n};\n\n/**\n * Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.\n */\nArray.prototype.sequenceEqual = function <T>(list: T[]): boolean {\n  return !!this.reduce((x: unknown, y: T, z: number) =>\n    list[z] === y ? x : undefined,\n  );\n};\n\n/**\n * Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.\n */\nArray.prototype.single = function <T>(\n  predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n): T {\n  if (this.count(predicate) !== 1) {\n    throw new Error(\n      'InvalidOperationException: The collection does not contain exactly one element.',\n    );\n  } else {\n    return this.first(predicate);\n  }\n};\n\n/**\n * Returns the only element of a sequence, or a default value if the sequence is empty;\n * this method throws an exception if there is more than one element in the sequence.\n */\nArray.prototype.singleOrDefault = function <T>(\n  predicate?: (value?: T, index?: number, list?: T[]) => boolean,\n): T | null {\n  return this.count(predicate) ? this.single(predicate) : null;\n};\n\n/**\n * Bypasses a specified number of elements in a sequence and then returns the remaining elements.\n */\nArray.prototype.skip = function <T>(amount: number): T[] {\n  return this.slice(Math.max(0, amount));\n};\n\n/**\n * Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.\n */\nArray.prototype.skipWhile = function <T>(\n  predicate: (value: T, index?: number, list?: T[]) => boolean,\n): T[] {\n  return this.skip(\n    this.aggregate(\n      (ac: number) => (predicate(this.elementAt(ac)) ? ++ac : ac),\n      0,\n    ),\n  );\n};\n\n/**\n * Computes the sum of the sequence of number values that are obtained by invoking\n * a transform function on each element of the input sequence.\n */\nArray.prototype.sum = function <T>(\n  transform?: (value?: T, index?: number, list?: T[]) => number,\n): number {\n  return transform\n    ? this.select(transform).sum()\n    : this.aggregate((ac: number, v: string | number) => (ac += +v), 0);\n};\n\n/**\n * Returns a specified number of contiguous elements from the start of a sequence.\n */\nArray.prototype.take = function <T>(amount: number): T[] {\n  return this.slice(0, Math.max(0, amount));\n};\n\n/**\n * Returns elements from a sequence as long as a specified condition is true.\n */\nArray.prototype.takeWhile = function <T>(\n  predicate: (value: T, index?: number, list?: T[]) => boolean,\n): T[] {\n  return this.take(\n    this.aggregate(\n      (ac: number) => (predicate(this.elementAt(ac)) ? ++ac : ac),\n      0,\n    ),\n  );\n};\n\n/**\n * Produces the set union of two sequences by using the default equality comparer.\n */\nArray.prototype.union = function <T>(list: T[]): T[] {\n  return this.concat(list).distinctBy((m) => m);\n};\n\n/**\n * Filters a sequence of values based on a predicate.\n */\nArray.prototype.where = function <T>(\n  predicate: (value: T, index?: number, list?: T[]) => boolean,\n): T[] {\n  return this.filter(predicate);\n};\n\n/**\n * Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.\n */\nArray.prototype.zip = function <U, T, TOut>(\n  list: U[],\n  result: (first: T, second: U) => TOut,\n): TOut[] {\n  return list.count() < this.count()\n    ? list.select((x, y) => result(this.elementAt(y), x))\n    : this.select((x: T, y: number) => result(x, list.elementAt(y)));\n};\n"],"names":[],"mappings":"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"}