feat: add filterMap for array

Author: alexkvak

src/array/__tests__/filterMap.ts

@@ -0,0 +1,51 @@
+import filterMap from '../filterMap';
+import map from '../map';
+import filter from '../filter';
+
+describe('utils/array/filterMap', () => {
+    it('should filter and map arrays', () => {
+        expect(
+            filterMap(
+                () => true,
+                (x) => x,
+                [1]
+            )
+        ).toEqual([1]);
+        expect(
+            filterMap(
+                () => false,
+                (x) => x,
+                [1]
+            )
+        ).toEqual([]);
+        expect(
+            filterMap(
+                (x) => x > 2,
+                (x) => x,
+                [1, 2, 3, 4, 5]
+            )
+        ).toEqual([3, 4, 5]);
+        expect(
+            filterMap(
+                () => false,
+                (x) => x,
+                [1, 2, 3, 4, 5]
+            )
+        ).toEqual([]);
+        expect(
+            filterMap(
+                (n) => n % 2 === 0,
+                (x) => x * 2,
+                [1, 2, 3, 4]
+            )
+        ).toEqual([4, 8]);
+    });
+
+    it('is equivalent to filter + map', () => {
+        const isEven = (n) => n % 2 === 0;
+        const double = (x) => x * 2;
+        const arr = [1, 2, 3, 4];
+
+        expect(filterMap(isEven, double, arr)).toEqual(map(double, filter(isEven, [1, 2, 3, 4])));
+    });
+});

src/array/filterMap.ts

@@ -0,0 +1,36 @@
+import curryN from '../function/curryN';
+import { ArrPred, MapFunc } from '../typings/types';
+
+interface FilterMap {
+    <T, R>(filterFn: ArrPred<T>, mapFn: MapFunc<T, R>, arr: ArrayLike<T>): R[];
+    <T, R>(filterFn: ArrPred<T>, mapFn: MapFunc<T, R>): (arr: ArrayLike<T>) => R[];
+}
+
+/**
+ * This is shortcut for filter + map, but applied in one iteration.
+ *
+ * @param {Function} filterFn - filter function
+ * @param {Function} mapFn - map function
+ * @param {Array} arr
+ * @return {Array}
+ * @example
+ *
+ *      var isEven = n => n % 2 === 0;
+ *      var double = x => x * 2;
+ *
+ *      filterMap(isEven, double, [1, 2, 3, 4]); //=> [4, 8]
+ *
+ *      // this is equivalent to
+ *      // map(double, filter(isEven, [1, 2, 3, 4]));
+ */
+export default curryN(3, <T, R>(filterFn: ArrPred<T>, mapFn: MapFunc<T, R>, arr: ArrayLike<T> = []) => {
+    const result: R[] = [];
+
+    for (let i = 0; i < arr.length; i++) {
+        if (filterFn(arr[i], i, arr)) {
+            result.push(mapFn(arr[i], i, arr));
+        }
+    }
+
+    return result;
+}) as FilterMap;

src/array/map.ts

@@ -1,6 +1,5 @@
 import curryN from '../function/curryN';
-
-type MapFunc<T, R> = (item: T, i: number, arr: ArrayLike<T>) => R;
+import { MapFunc } from '../typings/types';
 
 interface Map {
     <T, R>(fn: MapFunc<T, R>, arr: ArrayLike<T>): R[];
@@ -22,7 +21,7 @@ interface Map {
  */
 export default curryN(2, <T, R>(fn: MapFunc<T, R>, arr: ArrayLike<T> = []) => {
     const len = arr.length;
-    const result = new Array(len);
+    const result: R[] = new Array(len);
 
     for (let i = 0; i < len; i++) {
         result[i] = fn(arr[i], i, arr);

src/typings/types.ts

@@ -32,6 +32,8 @@ export type ArrPred<T = any> = ArrBase<T, boolean>;
 export type ObjPred<K extends Prop, V> = ObjBase<K, V, boolean>;
 export type ObjPredBy<O> = ObjBaseBy<O, boolean>;
 
+export type MapFunc<T, R> = (item: T, i: number, arr: ArrayLike<T>) => R;
+
 export type Func<R = any> = (...args) => R;
 export type Func1<R = any> = (arg) => R;