feat: _mapBy

src/array/array.util.test.ts

@@ -13,6 +13,7 @@ import {
   _intersection,
   _last,
   _lastOrUndefined,
+  _mapBy,
   _mapToObject,
   _max,
   _maxBy,
@@ -97,19 +98,38 @@ test('_by', () => {
     ab: { a: 'ab' },
   })
 
-  r = _by(a, v => v.a)
-  expect(r).toEqual({
-    aa: { a: 'aa' },
-    ab: { a: 'ab' },
-  })
-
   r = _by(a, v => v.a?.toUpperCase())
   expect(r).toEqual({
     AA: { a: 'aa' },
     AB: { a: 'ab' },
   })
 })
 
+test('_mapBy', () => {
+  const a = [{ a: 'aa' }, { a: 'ab' }, { b: 'bb' }]
+  expect(_mapBy(a, r => r.a)).toMatchInlineSnapshot(`
+    Map {
+      "aa" => {
+        "a": "aa",
+      },
+      "ab" => {
+        "a": "ab",
+      },
+    }
+  `)
+
+  expect(_mapBy(a, r => r.a?.toUpperCase())).toMatchInlineSnapshot(`
+    Map {
+      "AA" => {
+        "a": "aa",
+      },
+      "AB" => {
+        "a": "ab",
+      },
+    }
+  `)
+})
+
 test('_groupBy', () => {
   expect(_groupBy(_range(5), n => (n % 2 ? 'odd' : 'even'))).toEqual({
     even: [0, 2, 4],

src/array/array.util.ts

@@ -114,11 +114,24 @@ export function _uniqBy<T>(arr: readonly T[], mapper: Mapper<T, any>): T[] {
  * Returning `undefined` from the Mapper will EXCLUDE the item.
  */
 export function _by<T>(items: readonly T[], mapper: Mapper<T, any>): StringMap<T> {
-  return items.reduce((map, item, index) => {
-    const res = mapper(item, index)
-    if (res !== undefined) map[res] = item
-    return map
-  }, {} as StringMap<T>)
+  return Object.fromEntries(
+    items.map((item, i) => [mapper(item, i), item]).filter(([k]) => k !== undefined) as [any, T][],
+  )
+}
+
+/**
+ * Map an array of items by a key, that is calculated by a Mapper.
+ */
+export function _mapBy<ITEM, KEY>(
+  items: readonly ITEM[],
+  mapper: Mapper<ITEM, KEY>,
+): Map<KEY, ITEM> {
+  return new Map(
+    items.map((item, i) => [mapper(item, i), item]).filter(([k]) => k !== undefined) as [
+      KEY,
+      ITEM,
+    ][],
+  )
 }
 
 /**