feat(mergeMapObject): add mergeMapObject function

Author: djcsdy

index.test.ts

@@ -3,6 +3,7 @@ import test from "ava";
 import {expectType} from "ts-expect";
 import type {Key} from "./index";
 import {
+    mergeMapObject,
     copy,
     entries,
     excludeNullProperties,
@@ -159,6 +160,37 @@ test("mapObjectValues", t => {
     );
 });
 
+test("mergeMapObject", t => {
+    const a = {
+        a: 1,
+        b: 2
+    } as const;
+
+    const sa = Symbol();
+    const sb = Symbol();
+
+    const symbols: Record<string, symbol> = {
+        a: sa,
+        b: sb
+    };
+
+    t.deepEqual(
+        mergeMapObject(a, (key, value) => ({
+            [notNull(symbols[key])]: value + 1,
+            [`a${key}`]: value + 2,
+            [`b${key}`]: value * 2
+        })),
+        {
+            [sa]: 2,
+            [sb]: 3,
+            aa: 3,
+            ab: 4,
+            ba: 2,
+            bb: 4
+        }
+    );
+});
+
 test("filterObject", t => {
     const object = {
         a: 1,

index.ts

@@ -386,6 +386,25 @@ export function mapObjectValuesFn<TObject extends object, TNewValue>(
     return object => mapObjectValues(object, f);
 }
 
+/** Creates a new object by calling the specified mapping function for each
+ * key-value pair in the specified object, and then merging the returned
+ * objects.
+ *
+ * Only the string-keyed properties of the input object are considered, but
+ * the mapping function may produce keys of any suitable type.
+ *
+ * If the mapping function returns multiple objects that have the same key,
+ * then later values will overwrite earlier ones. */
+export function mergeMapObject<TObject extends object, TNewKey extends Key, TNewValue>(
+    object: Readonly<TObject>,
+    f: (
+        key: StringKey<TObject>,
+        value: StringKeyedValue<TObject>
+    ) => Readonly<Record<TNewKey, TNewValue>>
+): Record<TNewKey, TNewValue> {
+    return mergeRecords(map(entries(object), ([key, value]) => f(key, value)));
+}
+
 /** Creates a new object that contains the string-keyed properties of the
  * specified object, filtered by the specified predicate. */
 export function filterObject<T extends object>(