feat(compat): implement meanBy

benchmarks/performance/meanBy.bench.ts

@@ -1,8 +1,10 @@
 import { bench, describe } from 'vitest';
 import { meanBy as meanByToolkit_ } from 'es-toolkit';
+import { meanBy as meanByToolkitCompat_ } from 'es-toolkit/compat';
 import { meanBy as meanByLodash_ } from 'lodash';
 
 const meanByToolkit = meanByToolkit_;
+const meanByToolkitCompat = meanByToolkitCompat_;
 const meanByLodash = meanByLodash_;
 
 describe('meanBy', () => {
@@ -11,6 +13,11 @@ describe('meanBy', () => {
     meanByToolkit(items, x => x.a);
   });
 
+  bench('es-toolkit/compat/meanBy', () => {
+    const items = [{ a: 1 }, { a: 2 }, { a: 3 }];
+    meanByToolkitCompat(items, x => x.a);
+  });
+
   bench('lodash/meanBy', () => {
     const items = [{ a: 1 }, { a: 2 }, { a: 3 }];
     meanByLodash(items, x => x.a);
@@ -24,6 +31,10 @@ describe('meanBy/largeArray', () => {
     meanByToolkit(largeArray, x => x.a);
   });
 
+  bench('es-toolkit/compat/meanBy', () => {
+    meanByToolkitCompat(largeArray, x => x.a);
+  });
+
   bench('lodash/meanBy', () => {
     meanByLodash(largeArray, x => x.a);
   });

src/compat/index.ts

@@ -118,6 +118,7 @@ export { inRange } from './math/inRange.ts';
 export { max } from './math/max.ts';
 export { maxBy } from './math/maxBy.ts';
 export { mean } from './math/mean.ts';
+export { meanBy } from './math/meanBy.ts';
 export { min } from './math/min.ts';
 export { minBy } from './math/minBy.ts';
 export { multiply } from './math/multiply.ts';

src/compat/math/meanBy.spec.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { meanBy } from './meanBy';
+import { slice } from '../_internal/slice';
+
+describe('meanBy', () => {
+  const objects = [{ a: 2 }, { a: 3 }, { a: 1 }];
+
+  it('should work with an `iteratee`', () => {
+    const actual = meanBy(objects, object => object.a);
+
+    expect(actual).toEqual(2);
+  });
+
+  it('should provide correct `iteratee` arguments', () => {
+    let args: any;
+
+    // @ts-expect-error - invalid args
+    meanBy(objects, function () {
+      args || (args = slice.call(arguments));
+    });
+
+    expect(args).toEqual([{ a: 2 }]);
+  });
+
+  it('should work with `_.property` shorthands', () => {
+    const arrays = [[2], [3], [1]];
+    expect(meanBy(arrays, 0)).toBe(2);
+    expect(meanBy(objects, 'a')).toBe(2);
+  });
+});

src/compat/math/meanBy.ts

@@ -0,0 +1,35 @@
+import { meanBy as meanByToolkit } from '../../math/meanBy.ts';
+import { iteratee as iterateeToolkit } from '../util/iteratee.ts';
+
+/**
+ * Calculates the average of an array of numbers when applying
+ * the `iteratee` function to each element.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items An array to calculate the average.
+ * @param {((element: T) => number) | keyof T | [keyof T, unknown] | Partial<T>} iteratee
+ * The criteria used to determine the maximum value.
+ *  - If a **function** is provided, it extracts a numeric value from each element.
+ *  - If a **string** is provided, it is treated as a key to extract values from the objects.
+ *  - If a **[key, value]** pair is provided, it matches elements with the specified key-value pair.
+ *  - If an **object** is provided, it matches elements that contain the specified properties.
+ * @returns {number} The average of all the numbers as determined by the `iteratee` function.
+ *
+ * @example
+ * meanBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 2
+ * meanBy([], x => x.a); // Returns: NaN
+ * meanBy([[2], [3], [1]], 0); // Returns: 2
+ * meanBy([{ a: 2 }, { a: 3 }, { a: 1 }], 'a'); // Returns: 2
+ */
+export function meanBy<T>(
+  items: ArrayLike<T> | null | undefined,
+  iteratee: ((element: T) => number) | keyof T | [keyof T, unknown] | Partial<T>
+): number {
+  if (items == null) {
+    return NaN;
+  }
+
+  return meanByToolkit(Array.from(items), iterateeToolkit(iteratee));
+}