@vanillaes/absurdum 2.0.7 → 2.0.11

package/src/arrays/findLastIndex.d.ts

@@ -1,12 +1,11 @@
 /**
  * FindLastIndex method returns the value of Last element at which a provided function is true,
  * or undefined if no elements in the array satisfy the function.
- *
- * @param {Array} array input array
+ * @template T
+ * @param {T[]} array input array
  * @param {Function} predicate to be run against each element of the array
  * @param {*} [thisArg] this argument in the function
  * @returns {*} value of element that satisfied function.
- *
  * @example
  * const result = arrays.findLastIndex([5, 12, 8, 130, 44], (x) => x < 10);
  * console.log(result);
@@ -16,4 +15,4 @@
  * console.log(result);
  * > 3
  */
-export function findLastIndex(array: any[], predicate: Function, thisArg?: any): any;
+export function findLastIndex<T>(array: T[], predicate: Function, thisArg?: any): any;

package/src/arrays/findLastIndex.js

@@ -3,7 +3,8 @@
 /**
  * FindLastIndex method returns the value of Last element at which a provided function is true,
  * or undefined if no elements in the array satisfy the function.
- * @param {Array} array input array
+ * @template T
+ * @param {T[]} array input array
  * @param {Function} predicate to be run against each element of the array
  * @param {*} [thisArg] this argument in the function
  * @returns {*} value of element that satisfied function.
@@ -16,7 +17,7 @@
  * console.log(result);
  * > 3
  */
-function findLastIndex (array, predicate, thisArg) {
+export function findLastIndex (array, predicate, thisArg) {
   if (array.length === 0) return -1
   if (typeof predicate !== 'function') { throw TypeError('predicate must be a function') }
   if (predicate.call(thisArg, array[array.length - 1])) return array.length - 1
@@ -26,7 +27,5 @@ function findLastIndex (array, predicate, thisArg) {
     if (i === array.length - 2) return predicate.call(thisArg, cur) ? i : -1
     if (res < 0 && predicate.call(thisArg, cur)) return i
     return res
-  })
+  }, -1)
 }
-
-export { findLastIndex }

package/src/arrays/flat.d.ts

@@ -1,13 +1,12 @@
 /**
  * Flat flattens an array of nested arrays
- *
- * @param {Array} array input array
- * @param {number} [depth=1] depth of array elements to flat
- * @returns {Array} the flattened array
- *
+ * @template T
+ * @param {T[]} array input array
+ * @param {number} [depth] depth of array elements to flat (default 1)
+ * @returns {T[]} the flattened array
  * @example
  * const result = arrays.flat([1, [2, [3, [4]]]]);
  * console.log(result);
  * > [1, 2, [3, [4]]]
  */
-export function flat(array: any[], depth?: number): any[];
+export function flat<T>(array: T[], depth?: number): T[];

package/src/arrays/flat.js

@@ -1,15 +1,16 @@
 /**
  * Flat flattens an array of nested arrays
- * @param {Array} array input array
+ * @template T
+ * @param {T[]} array input array
  * @param {number} [depth] depth of array elements to flat (default 1)
- * @returns {Array} the flattened array
+ * @returns {T[]} the flattened array
  * @example
  * const result = arrays.flat([1, [2, [3, [4]]]]);
  * console.log(result);
  * > [1, 2, [3, [4]]]
  */
-function flat (array, depth = 1) {
-  return array.reduce((acc, curr) => {
+export function flat (array, depth = 1) {
+  return array.reduce((/** @type {T[]} */ acc, curr) => {
     if (Array.isArray(curr) && depth > 0) {
       acc.push(...flat(curr, depth - 1))
     } else {
@@ -18,5 +19,3 @@ function flat (array, depth = 1) {
     return acc
   }, [])
 }
-
-export { flat }

package/src/arrays/frequency.d.ts

@@ -1,13 +1,14 @@
 /**
  * Frequency returns an object mapping each unique item in an array
  * to the number of items it occurs in the array.
- *
- * @param {Array} array input array
- * @returns {Object} object of uniq values and their frequency of occurrence
- *
+ * @template T
+ * @param {T[]} array input array
+ * @returns {{[key: T]: number}} object of uniq values and their frequency of occurrence
  * @example
  * const result = arrays.frequency(['a', 'b', 'a', 'c', 'a', 'c', 'b']);
  * console.log(result)
  * > { a: 3, b: 2, c: 2 }
  */
-export function frequency(array: any[]): any;
+export function frequency<T>(array: T[]): {
+    [key: T]: number;
+};

package/src/arrays/frequency.js

@@ -1,18 +1,19 @@
+/* eslint-disable jsdoc/check-types */
+
 /**
  * Frequency returns an object mapping each unique item in an array
  * to the number of items it occurs in the array.
- * @param {Array} array input array
- * @returns {object} object of uniq values and their frequency of occurrence
+ * @template T
+ * @param {T[]} array input array
+ * @returns {{[key: T]: number}} object of uniq values and their frequency of occurrence
  * @example
  * const result = arrays.frequency(['a', 'b', 'a', 'c', 'a', 'c', 'b']);
  * console.log(result)
  * > { a: 3, b: 2, c: 2 }
  */
-function frequency (array) {
-  return array.reduce((acc, curr) => {
-    acc[curr] = acc[curr] ? ++acc[curr] : 1
+export function frequency (array) {
+  return array.reduce((/** @type {Object.<T, number>} */ acc, curr) => {
+    acc[curr] = acc[curr] ? acc[curr] += 1 : 1
     return acc
   }, {})
 }
-
-export { frequency }

package/src/arrays/intersection.d.ts

@@ -1,12 +1,11 @@
 /**
  * Intersection creates an array of unique values that are included in all given arrays
- *
- * @param {Array} arrays input array(s)
- * @returns {Array} an array containing the unique intersecting values between all input arrays
- *
+ * @template T
+ * @param {T[]} arrays input array(s)
+ * @returns {T[]} an array containing the unique intersecting values between all input arrays
  * @example
- * const result = arrays.intersection([4, 2, 1], [2, 3, 4]));
+ * const result = arrays.intersection([4, 2, 1], [2, 3, 4]);
  * console.log(result);
  * > [4, 2]
  */
-export function intersection(...arrays: any[]): any[];
+export function intersection<T>(...arrays: T[]): T[];

package/src/arrays/intersection.js

@@ -1,13 +1,16 @@
+// @ts-nocheck TODO: Fix types on this later
+
 /**
  * Intersection creates an array of unique values that are included in all given arrays
- * @param {Array} arrays input array(s)
- * @returns {Array} an array containing the unique intersecting values between all input arrays
+ * @template T
+ * @param {T[]} arrays input array(s)
+ * @returns {T[]} an array containing the unique intersecting values between all input arrays
  * @example
- * const result = arrays.intersection([4, 2, 1], [2, 3, 4]));
+ * const result = arrays.intersection([4, 2, 1], [2, 3, 4]);
  * console.log(result);
  * > [4, 2]
  */
-function intersection (...arrays) {
+export function intersection (...arrays) {
   return [...new Set(arguments[0])].reduce((acc, curr) => {
     if (arrays.slice(1).reduce((every, array, i) => {
       if (every && !new Set(array).has(curr)) return false
@@ -18,5 +21,3 @@ function intersection (...arrays) {
     return acc
   }, [])
 }
-
-export { intersection }

package/src/arrays/map.d.ts

@@ -1,13 +1,12 @@
 /**
  * Map iterates over an array of values and applies a function to each value
- *
- * @param {Array} array input array
+ * @template T
+ * @param {T[]} array input array
  * @param {Function} func function describing how to map values
- * @returns {Array} array of mutated values
- *
+ * @returns {T[]} array of mutated values
  * @example
  * const result = arrays.map([1, 2, 3, 4], (x) => x + 2);
  * console.log(result)
  * > [ 3, 4, 5, 6 ]
  */
-export function map(array: any[], func: Function): any[];
+export function map<T>(array: T[], func: Function): T[];

package/src/arrays/map.js

@@ -2,20 +2,19 @@
 
 /**
  * Map iterates over an array of values and applies a function to each value
- * @param {Array} array input array
+ * @template T
+ * @param {T[]} array input array
  * @param {Function} func function describing how to map values
- * @returns {Array} array of mutated values
+ * @returns {T[]} array of mutated values
  * @example
  * const result = arrays.map([1, 2, 3, 4], (x) => x + 2);
  * console.log(result)
  * > [ 3, 4, 5, 6 ]
  */
-function map (array, func) {
+export function map (array, func) {
   if (!func) { return array }
-  return array.reduce((acc, curr) => {
+  return array.reduce((/** @type {T[]} */ acc, curr) => {
     acc.push(func(curr))
     return acc
   }, [])
 }
-
-export { map }

package/src/arrays/pull.d.ts

@@ -1,13 +1,12 @@
 /**
  * Pull removes all of the given values from an array
- *
- * @param {Array} array input array
+ * @template T
+ * @param {T[]} array input array
  * @param {...*} values values to be removed from the array
- * @returns {Array} array of with values removed
- *
+ * @returns {T[]} array of with values removed
  * @example
  * const result = arrays.pull([1, 2, 3, 4], 2, 4);
  * console.log(result)
  * > [1, 3]
  */
-export function pull(array: any[], ...values: any[]): any[];
+export function pull<T>(array: T[], ...values: any[]): T[];

package/src/arrays/pull.js

@@ -2,20 +2,19 @@
 
 /**
  * Pull removes all of the given values from an array
- * @param {Array} array input array
+ * @template T
+ * @param {T[]} array input array
  * @param {...*} values values to be removed from the array
- * @returns {Array} array of with values removed
+ * @returns {T[]} array of with values removed
  * @example
  * const result = arrays.pull([1, 2, 3, 4], 2, 4);
  * console.log(result)
  * > [1, 3]
  */
-function pull (array, ...values) {
+export function pull (array, ...values) {
   const valueSet = new Set(values)
-  return array.reduce((acc, curr) => {
+  return array.reduce((/** @type {T[]} */ acc, curr) => {
     if (!valueSet.has(curr)) { acc.push(curr) }
     return acc
   }, [])
 }
-
-export { pull }

package/src/arrays/take.d.ts

@@ -1,10 +1,9 @@
 /**
  * Take method returns a slice of array with 'count' number of elements from the beginning
- *
- * @param {Array} array input array
- * @param {Number} [count=1] number of elements in the slice of the array
- * @returns {Array} the slice of the array of length 'count'
- *
+ * @template T
+ * @param {T[]} array input array
+ * @param {number} [count] number of elements in the slice of the array (default 1)
+ * @returns {T[]} the slice of the array of length 'count'
  * @example
  * const result = arrays.take(['Amy', 'Brie', 'Cam', 'Dimitri']);
  * console.log(result);
@@ -14,4 +13,4 @@
  * console.log(result);
  * > ['Amy', 'Brie', 'Cam']
  */
-export function take(array: any[], count?: number): any[];
+export function take<T>(array: T[], count?: number): T[];

package/src/arrays/take.js

@@ -1,8 +1,9 @@
 /**
  * Take method returns a slice of array with 'count' number of elements from the beginning
- * @param {Array} array input array
+ * @template T
+ * @param {T[]} array input array
  * @param {number} [count] number of elements in the slice of the array (default 1)
- * @returns {Array} the slice of the array of length 'count'
+ * @returns {T[]} the slice of the array of length 'count'
  * @example
  * const result = arrays.take(['Amy', 'Brie', 'Cam', 'Dimitri']);
  * console.log(result);
@@ -12,11 +13,9 @@
  * console.log(result);
  * > ['Amy', 'Brie', 'Cam']
  */
-function take (array, count = 1) {
-  return array.reduce((res, cur, i) => {
+export function take (array, count = 1) {
+  return array.reduce((/** @type {T[]} */ res, cur, i) => {
     if (i < count) { res.push(cur) }
     return res
   }, [])
 }
-
-export { take }

package/src/arrays/takeRight.d.ts

@@ -1,10 +1,9 @@
 /**
  * Take method returns a slice of array with 'count' number of elements from the end of the array
- *
- * @param {Array} array input array
- * @param {Number} [count=1] number of elements in the slice of the array
- * @returns {Array} the slice of the array of length 'count'
- *
+ * @template T
+ * @param {T[]} array input array
+ * @param {number} [count] number of elements in the slice of the array (default 1)
+ * @returns {T[]} the slice of the array of length 'count'
  * @example
  * const result = arrays.some(['Amy', 'Brie', 'Cam', 'Dimitri']);
  * console.log(result);
@@ -14,4 +13,4 @@
  * console.log(result);
  * > ['Brie', 'Cam', 'Dimitri']
  */
-export function takeRight(array: any[], count?: number): any[];
+export function takeRight<T>(array: T[], count?: number): T[];

package/src/arrays/takeRight.js

@@ -1,8 +1,9 @@
 /**
  * Take method returns a slice of array with 'count' number of elements from the end of the array
- * @param {Array} array input array
+ * @template T
+ * @param {T[]} array input array
  * @param {number} [count] number of elements in the slice of the array (default 1)
- * @returns {Array} the slice of the array of length 'count'
+ * @returns {T[]} the slice of the array of length 'count'
  * @example
  * const result = arrays.some(['Amy', 'Brie', 'Cam', 'Dimitri']);
  * console.log(result);
@@ -12,12 +13,10 @@
  * console.log(result);
  * > ['Brie', 'Cam', 'Dimitri']
  */
-function takeRight (array, count = 1) {
+export function takeRight (array, count = 1) {
   const start = array.length - 1 - count
-  return array.reduce((res, cur, i) => {
+  return array.reduce((/** @type {T[]} */ res, cur, i) => {
     if (i > start) { res.push(cur) }
     return res
   }, [])
 }
-
-export { takeRight }

package/src/arrays/union.d.ts

@@ -1,11 +1,10 @@
 /**
  * Union creates an array of unique elements from all given arrays in order encountered
- *
- * @param {Array} arrays input arrays
- * @returns {Array} an array of unique elements from all given arrays
- *
+ * @template T
+ * @param {T[]} arrays input arrays
+ * @returns {T[]} an array of unique elements from all given arrays
  * @example
  * const result = arrays.union([2], [1, 2, 3, 1]);
  * > [2, 1, 3]
  */
-export function union(...arrays: any[]): any[];
+export function union<T>(...arrays: T[]): T[];

package/src/arrays/union.js

@@ -1,12 +1,13 @@
 /**
  * Union creates an array of unique elements from all given arrays in order encountered
- * @param {Array} arrays input arrays
- * @returns {Array} an array of unique elements from all given arrays
+ * @template T
+ * @param {T[]} arrays input arrays
+ * @returns {T[]} an array of unique elements from all given arrays
  * @example
  * const result = arrays.union([2], [1, 2, 3, 1]);
  * > [2, 1, 3]
  */
-function union (...arrays) {
+export function union (...arrays) {
   return Array.from([...arrays].reduce((acc, curr) => {
     if (Array.isArray(curr)) {
       curr.reduce((res, cur) => {
@@ -17,5 +18,3 @@ function union (...arrays) {
     return acc
   }, new Set()))
 }
-
-export { union }

package/src/arrays/unique.d.ts

@@ -1,12 +1,11 @@
 /**
  * Removes all duplicate items of an array
- *
- * @param {Array} array input array
- * @returns {Array} an array of unique values
- *
+ * @template T
+ * @param {T[]} array input array
+ * @returns {T[]} an array of unique values
  * @example
  * const result = arrays.unique([2, 1, 2]);
  * console.log(result);
  * > [2, 1]
  */
-export function unique(array: any[]): any[];
+export function unique<T>(array: T[]): T[];

package/src/arrays/unique.js

@@ -1,17 +1,16 @@
 /**
  * Removes all duplicate items of an array
- * @param {Array} array input array
- * @returns {Array} an array of unique values
+ * @template T
+ * @param {T[]} array input array
+ * @returns {T[]} an array of unique values
  * @example
  * const result = arrays.unique([2, 1, 2]);
  * console.log(result);
  * > [2, 1]
  */
-function unique (array) {
+export function unique (array) {
   return [...array.reduce((acc, curr) => {
     acc.add(curr)
     return acc
   }, new Set())]
 }
-
-export { unique }

package/src/arrays/unzip.d.ts

@@ -1,12 +1,11 @@
 /**
  * Performs a manipulation to undo the zip command
- *
- * @param {Array} array input array
- * @returns {Array} an array of unique values
- *
+ * @template T
+ * @param {T[]} array input array
+ * @returns {T[]} an array of unique values
  * @example
  * const result = arrays.unzip([['a', 'b', 'c'], [1, 2, 3], [true, false, true]]);
  * console.log(result);
  * > [['a', 1, true], ['b', 2, false], ['c', 3, true]]
  */
-export function unzip(array: any[]): any[];
+export function unzip<T>(array: T[]): T[];

package/src/arrays/unzip.js

@@ -1,13 +1,16 @@
+// @ts-nocheck TODO: Fix types on this later
+
 /**
  * Performs a manipulation to undo the zip command
- * @param {Array} array input array
- * @returns {Array} an array of unique values
+ * @template T
+ * @param {T[]} array input array
+ * @returns {T[]} an array of unique values
  * @example
  * const result = arrays.unzip([['a', 'b', 'c'], [1, 2, 3], [true, false, true]]);
  * console.log(result);
  * > [['a', 1, true], ['b', 2, false], ['c', 3, true]]
  */
-function unzip (array) {
+export function unzip (array) {
   const res = new Array(array.reduce((acc, curr) => {
     return curr.length > acc ? curr.length : acc
   }, 0)).fill(undefined)
@@ -21,5 +24,3 @@ function unzip (array) {
     return acc
   }, [])
 }
-
-export { unzip }

package/src/arrays/without.d.ts

@@ -1,12 +1,12 @@
 /**
  * Without, returns an array with all values parameters removed from the input array
- *
- * @param {Array} array input array
+ * @template T
+ * @param {T[]} array input array
  * @param {...*} values input values
- * @returns {Array} an array of unique values
+ * @returns {T[]} an array of unique values
  * @example
  * const result = arrays.without(['a', 'b', 'c', ['d']], 'b', ['d']);
  * console.log(result);
  * > ['a', 'c', ['d']]
  */
-export function without(array: any[], ...values: any[]): any[];
+export function without<T>(array: T[], ...values: any[]): T[];

package/src/arrays/without.js

@@ -2,20 +2,19 @@
 
 /**
  * Without, returns an array with all values parameters removed from the input array
- * @param {Array} array input array
+ * @template T
+ * @param {T[]} array input array
  * @param {...*} values input values
- * @returns {Array} an array of unique values
+ * @returns {T[]} an array of unique values
  * @example
  * const result = arrays.without(['a', 'b', 'c', ['d']], 'b', ['d']);
  * console.log(result);
  * > ['a', 'c', ['d']]
  */
-function without (array, ...values) {
+export function without (array, ...values) {
   const toExclude = new Set(values)
-  return array.reduce((acc, curr) => {
+  return array.reduce((/** @type {T[]} */ acc, curr) => {
     if (!toExclude.has(curr)) { acc.push(curr) }
     return acc
   }, [])
 }
-
-export { without }

package/src/arrays/xor.d.ts

@@ -1,12 +1,11 @@
 /**
  * Creates an array of unique values that is the symmetric difference of the given arrays
- *
- * @param {...Array} arrays input arrays
- * @returns {Array} an array of unique values
- *
+ * @template T
+ * @param {...T[]} arrays input arrays
+ * @returns {T[]} an array of unique values
  * @example
  * const result = arrays.xor(['a', 1, [5]], ['b', 1, 'a'], ['b', 'c', 5]);
  * console.log(result);
  * > [[5], 'c', 5]
  */
-export function xor(...arrays: any[][]): any[];
+export function xor<T>(...arrays: T[][]): T[];

package/src/arrays/xor.js

@@ -1,13 +1,14 @@
 /**
  * Creates an array of unique values that is the symmetric difference of the given arrays
- * @param {...Array} arrays input arrays
- * @returns {Array} an array of unique values
+ * @template T
+ * @param {...T[]} arrays input arrays
+ * @returns {T[]} an array of unique values
  * @example
  * const result = arrays.xor(['a', 1, [5]], ['b', 1, 'a'], ['b', 'c', 5]);
  * console.log(result);
  * > [[5], 'c', 5]
  */
-function xor (...arrays) {
+export function xor (...arrays) {
   if (arrays.length < 2) {
     if (arrays.length === 0) { return [] }
     return arrays[0]
@@ -15,7 +16,7 @@ function xor (...arrays) {
 
   const duplicates = new Set()
   const allUniq = arrays.reduce((collect, array) => {
-    const checker = array.reduce((acc, curr) => {
+    const checker = array.reduce((/** @type {T[]} */ acc, curr) => {
       if (collect.has(curr)) { acc.push(curr) }
       return acc
     }, [])
@@ -27,5 +28,3 @@ function xor (...arrays) {
   duplicates.forEach(val => allUniq.delete(val))
   return [...allUniq]
 }
-
-export { xor }

package/src/arrays/zip.d.ts

@@ -1,12 +1,11 @@
 /**
  * Zip applies a specified function to the corresponding elements of two sequences,
  * producing a sequence of the results.
- *
- * @param {Array} arrayA input array
- * @param {Array} ArrayB input array
- * @param {Function} [func=(a, b)=>[a, b]] to be applied to corresponding values
- * @returns {Array} input array filled value pairs after the function has been applied
- *
+ * @template T
+ * @param {T[]} arrayA input array
+ * @param {T[]} ArrayB input array
+ * @param {Function} [func] to be applied to corresponding values (default (a, b)=>[a, b])
+ * @returns {T[]} input array filled value pairs after the function has been applied
  * @example
  * const result = zip([5, 12, 8, 130, 44], ["ham", "cheese", "bread"]);
  * console.log(result)
@@ -16,4 +15,4 @@
  * console.log(result)
  * > [ 'ham 5', 'cheese 12', 'bread 8' ]
  */
-export function zip(arrayA: any[], ArrayB: any[], func?: Function): any[];
+export function zip<T>(arrayA: T[], ArrayB: T[], func?: Function): T[];