refactor: rename MF to Fs

RebeccaStevens · May 20, 2024 · 40bd69b · 40bd69b
1 parent 9300162
commit 40bd69b
Show file tree

Hide file tree

Showing 6 changed files with 72 additions and 72 deletions.
diff --git a/docs/deepmergeCustom.md b/docs/deepmergeCustom.md
@@ -170,7 +170,7 @@ declaring a module block for this library and defining the same interface.
 declare module "deepmerge-ts" {
   interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly MyCustomMergeURI: MyValue;
@@ -215,7 +215,7 @@ customDeepmerge(x, y, z); // => { foo: [Date, Date, Date] }
 declare module "deepmerge-ts" {
   interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly MyDeepMergeDatesURI: EveryIsDate<Ts> extends true
@@ -301,7 +301,7 @@ customizedDeepmerge(x, y, z); // => { key1: { subkey1: `one`, subkey2: `two` } }
 declare module "deepmerge-ts" {
   interface DeepMergeFunctionURItoKind<
     Ts extends Readonly<ReadonlyArray<unknown>>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly FilterNullValues: FilterOut<Ts, null>;
@@ -433,7 +433,7 @@ customizedDeepmerge(x, y); // => { foo: { bar: { baz: "special merge", bar: { ba
 declare module "deepmerge-ts" {
   interface DeepMergeFunctionURItoKind<
     Ts extends Readonly<ReadonlyArray<unknown>>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M, // This is the meta data type
   > {
     readonly KeyPathBasedMerge: Ts[number] extends number

diff --git a/src/deepmerge.ts b/src/deepmerge.ts
@@ -150,19 +150,19 @@ function getUtils<
 export function mergeUnknowns<
   Ts extends ReadonlyArray<unknown>,
   U extends DeepMergeFunctionUtils<M, MM>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
->(values: Ts, utils: U, meta: M | undefined): DeepMergeHKT<Ts, MF, M> {
+>(values: Ts, utils: U, meta: M | undefined): DeepMergeHKT<Ts, Fs, M> {
   const filteredValues = utils.filterValues?.(values, meta) ?? values;
 
   if (filteredValues.length === 0) {
-    return undefined as DeepMergeHKT<Ts, MF, M>;
+    return undefined as DeepMergeHKT<Ts, Fs, M>;
   }
   if (filteredValues.length === 1) {
     return mergeOthers<U, M, MM>(filteredValues, utils, meta) as DeepMergeHKT<
       Ts,
-      MF,
+      Fs,
       M
     >;
   }
@@ -177,35 +177,35 @@ export function mergeUnknowns<
 
       return mergeOthers<U, M, MM>(filteredValues, utils, meta) as DeepMergeHKT<
         Ts,
-        MF,
+        Fs,
         M
       >;
     }
   }
 
   switch (type) {
     case ObjectType.RECORD: {
-      return mergeRecords<U, MF, M, MM>(
+      return mergeRecords<U, Fs, M, MM>(
         filteredValues as ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
         utils,
         meta,
-      ) as DeepMergeHKT<Ts, MF, M>;
+      ) as DeepMergeHKT<Ts, Fs, M>;
     }
 
     case ObjectType.ARRAY: {
       return mergeArrays<U, M, MM>(
         filteredValues as ReadonlyArray<Readonly<ReadonlyArray<unknown>>>,
         utils,
         meta,
-      ) as DeepMergeHKT<Ts, MF, M>;
+      ) as DeepMergeHKT<Ts, Fs, M>;
     }
 
     case ObjectType.SET: {
       return mergeSets<U, M, MM>(
         filteredValues as ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
         utils,
         meta,
-      ) as DeepMergeHKT<Ts, MF, M>;
+      ) as DeepMergeHKT<Ts, Fs, M>;
     }
 
     case ObjectType.MAP: {
@@ -215,13 +215,13 @@ export function mergeUnknowns<
         >,
         utils,
         meta,
-      ) as DeepMergeHKT<Ts, MF, M>;
+      ) as DeepMergeHKT<Ts, Fs, M>;
     }
 
     default: {
       return mergeOthers<U, M, MM>(filteredValues, utils, meta) as DeepMergeHKT<
         Ts,
-        MF,
+        Fs,
         M
       >;
     }
@@ -235,7 +235,7 @@ export function mergeUnknowns<
  */
 function mergeRecords<
   U extends DeepMergeFunctionUtils<M, MM>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -255,7 +255,7 @@ function mergeRecords<
     return utils.defaultMergeFunctions.mergeRecords<
       ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
       U,
-      MF,
+      Fs,
       M,
       MM
     >(values, utils, meta);

diff --git a/src/defaults/vanilla.ts b/src/defaults/vanilla.ts
@@ -30,14 +30,14 @@ export type MergeFunctions = {
 export function mergeRecords<
   Ts extends ReadonlyArray<Record<PropertyKey, unknown>>,
   U extends DeepMergeFunctionUtils<M, MM>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   values: Ts,
   utils: U,
   meta: M | undefined,
-): DeepMergeRecordsDefaultHKT<Ts, MF, M> {
+): DeepMergeRecordsDefaultHKT<Ts, Fs, M> {
   const result: Record<PropertyKey, unknown> = {};
 
   for (const key of getKeys(values)) {
@@ -58,7 +58,7 @@ export function mergeRecords<
       parents: values,
     } as unknown as MM);
 
-    const propertyResult = mergeUnknowns<ReadonlyArray<unknown>, U, MF, M, MM>(
+    const propertyResult = mergeUnknowns<ReadonlyArray<unknown>, U, Fs, M, MM>(
       propValues,
       utils,
       updatedMeta,
@@ -80,7 +80,7 @@ export function mergeRecords<
     }
   }
 
-  return result as DeepMergeRecordsDefaultHKT<Ts, MF, M>;
+  return result as DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
 }
 
 /**
@@ -90,10 +90,10 @@ export function mergeRecords<
  */
 export function mergeArrays<
   Ts extends ReadonlyArray<ReadonlyArray<unknown>>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
->(values: Ts): DeepMergeArraysDefaultHKT<Ts, MF, M> {
-  return values.flat() as DeepMergeArraysDefaultHKT<Ts, MF, M>;
+>(values: Ts): DeepMergeArraysDefaultHKT<Ts, Fs, M> {
+  return values.flat() as DeepMergeArraysDefaultHKT<Ts, Fs, M>;
 }
 
 /**

diff --git a/src/types/defaults.ts b/src/types/defaults.ts
@@ -95,12 +95,12 @@ type RecordToRecordMeta<T extends Record<PropertyKey, unknown>> =
  */
 export type DeepMergeRecordsDefaultHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
 > =
   Ts extends ReadonlyArray<Record<PropertyKey, unknown>>
     ? SimplifyObject<
-        DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, MF, M>
+        DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, Fs, M>
       >
     : never;
 
@@ -109,11 +109,11 @@ export type DeepMergeRecordsDefaultHKT<
  */
 type DeepMergeRecordMetaDefaultHKTProps<
   RecordMetas,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
 > =
   RecordMetas extends ReadonlyArray<RecordMeta>
-    ? CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, MF, M>
+    ? CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, Fs, M>
     : never;
 
 type MergeRecordMeta<RecordMetas extends ReadonlyArray<RecordMeta>> =
@@ -143,15 +143,15 @@ type GroupValuesByKey<Ts> = Ts extends readonly [
     }
   : never;
 
-type CreateRecordFromMeta<Ts, MF extends DeepMergeFunctionsURIs, M> =
+type CreateRecordFromMeta<Ts, Fs extends DeepMergeFunctionsURIs, M> =
   Ts extends ReadonlyArray<unknown>
     ? TupleToIntersection<{
         [I in keyof Ts]: Ts[I] extends {
           key: infer Key extends PropertyKey;
           values: infer Values extends ReadonlyArray<unknown>;
           optional: infer O extends boolean;
         }
-          ? CreateRecordForKeyFromMeta<Key, Values, O, MF, M>
+          ? CreateRecordForKeyFromMeta<Key, Values, O, Fs, M>
           : never;
       }>
     : never;
@@ -160,14 +160,14 @@ type CreateRecordForKeyFromMeta<
   Key extends PropertyKey,
   Values extends ReadonlyArray<unknown>,
   Optional extends boolean,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
 > = Optional extends true
   ? {
-      [k in Key]+?: DeepMergeHKT<Values, MF, M>;
+      [k in Key]+?: DeepMergeHKT<Values, Fs, M>;
     }
   : {
-      [k in Key]-?: DeepMergeHKT<Values, MF, M>;
+      [k in Key]-?: DeepMergeHKT<Values, Fs, M>;
     };
 
 /**
@@ -267,16 +267,16 @@ type DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
  */
 export type DeepMergeArraysDefaultHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeArraysDefaultHKTHelper<Ts, MF, M, []>;
+> = DeepMergeArraysDefaultHKTHelper<Ts, Fs, M, []>;
 
 /**
  * Tail-recursive helper type for DeepMergeArraysDefaultHKT.
  */
 type DeepMergeArraysDefaultHKTHelper<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
   Acc extends ReadonlyArray<unknown>,
 > = Ts extends readonly [
@@ -287,7 +287,7 @@ type DeepMergeArraysDefaultHKTHelper<
       ReadonlyArray<unknown>,
       ...ReadonlyArray<ReadonlyArray<unknown>>,
     ]
-    ? DeepMergeArraysDefaultHKTHelper<Rest, MF, M, [...Acc, ...Head]>
+    ? DeepMergeArraysDefaultHKTHelper<Rest, Fs, M, [...Acc, ...Head]>
     : [...Acc, ...Head]
   : never;