From 02fcd3bbb33d8e4920175624450525436202737c Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Sun, 12 May 2024 22:41:46 +1200
Subject: [PATCH] fix: type when merging optional properties of a record

---
 project-dictionary.txt         |   2 +
 src/types/defaults.ts          | 230 ++++++++++++++++++++++++++-------
 src/types/utils.ts             | 219 +++++++++++++++----------------
 tests/deepmerge-into.test-d.ts |  14 ++
 tests/deepmerge.test-d.ts      |  11 ++
 5 files changed, 320 insertions(+), 156 deletions(-)

diff --git a/project-dictionary.txt b/project-dictionary.txt
index 287685d8..dd8f3ec0 100644
--- a/project-dictionary.txt
+++ b/project-dictionary.txt
@@ -19,6 +19,7 @@ kinded
 klass
 knip
 litecoin
+metas
 monero
 noreply
 octocat
@@ -29,5 +30,6 @@ Rebecca
 sonarjs
 Stevens
 thud
+tuplify
 waldo
 xyzzy
diff --git a/src/types/defaults.ts b/src/types/defaults.ts
index 1c5b138c..55ed9e8f 100644
--- a/src/types/defaults.ts
+++ b/src/types/defaults.ts
@@ -6,13 +6,14 @@ import {
 } from "./merging";
 import {
   type FilterOutNever,
+  type FlattenTuples,
   type FlatternAlias,
-  type OptionalKeysOf,
-  type RequiredKeysOf,
+  type TransposeTuple,
+  type TupleToIntersection,
+  type TuplifyUnion,
   type UnionMapKeys,
   type UnionMapValues,
   type UnionSetValues,
-  type ValueOfKey,
 } from "./utils";
 
 /**
@@ -46,6 +47,38 @@ export type DeepMergeMergeFunctionsDefaultURIs = Readonly<{
   DeepMergeOthersURI: DeepMergeLeafURI;
 }>;
 
+type RecordEntries<T extends Record<PropertyKey, unknown>> = TuplifyUnion<
+  {
+    [K in keyof T]: [K, T[K]];
+  }[keyof T]
+>;
+
+type RecordMeta = Record<PropertyKey, RecordPropertyMeta>;
+
+type RecordPropertyMeta<
+  Key extends PropertyKey = PropertyKey,
+  Value = unknown,
+  Optional extends boolean = boolean,
+> = {
+  key: Key;
+  value: Value;
+  optional: Optional;
+};
+
+type RecordsToRecordMeta<
+  Ts extends ReadonlyArray<Record<PropertyKey, unknown>>,
+> = {
+  [I in keyof Ts]: RecordToRecordMeta<Ts[I]>;
+};
+
+type RecordToRecordMeta<T extends Record<PropertyKey, unknown>> = {
+  [K in keyof T]-?: {
+    key: K;
+    value: Required<T>[K];
+    optional: {} extends Pick<T, K> ? true : false;
+  };
+};
+
 /**
  * Deep merge records.
  */
@@ -54,66 +87,169 @@ export type DeepMergeRecordsDefaultHKT<
   MF extends DeepMergeMergeFunctionsURIs,
   M,
 > =
-  Ts extends Readonly<readonly [unknown, ...Readonly<ReadonlyArray<unknown>>]>
-    ? FlatternAlias<DeepMergeRecordsDefaultHKTInternalProps<Ts, MF, M>>
-    : {};
+  Ts extends ReadonlyArray<Record<PropertyKey, unknown>>
+    ? FlatternAlias<
+        DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, MF, M>
+      >
+    : never;
 
 /**
  * Deep merge record props.
  */
-type DeepMergeRecordsDefaultHKTInternalProps<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>],
+type DeepMergeRecordMetaDefaultHKTProps<
+  RecordMetas extends ReadonlyArray<RecordMeta>,
   MF extends DeepMergeMergeFunctionsURIs,
   M,
-> = {
-  [K in OptionalKeysOf<Ts>]?: DeepMergeHKT<
-    DeepMergeRecordsDefaultHKTInternalPropValue<Ts, K, M>,
-    MF,
-    M
-  >;
-} & {
-  [K in RequiredKeysOf<Ts>]: DeepMergeHKT<
-    DeepMergeRecordsDefaultHKTInternalPropValue<Ts, K, M>,
-    MF,
-    M
+> = CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, MF, M>;
+
+type MergeRecordMeta<RecordMetas extends ReadonlyArray<RecordMeta>> =
+  GroupValuesByKey<
+    FlattenTuples<
+      TransposeTuple<{
+        [I in keyof RecordMetas]: TransposeTuple<RecordEntries<RecordMetas[I]>>;
+      }>
+    >
   >;
-};
 
-/**
- * Get the value of the property.
- */
-type DeepMergeRecordsDefaultHKTInternalPropValue<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>],
-  K extends PropertyKey,
+type GroupValuesByKey<Ts> = Ts extends readonly [
+  infer Keys extends ReadonlyArray<PropertyKey>,
+  infer Values,
+]
+  ? {
+      [I in keyof Keys]: DeepMergeRecordPropertyMetaDefaultHKTGetPossible<
+        Keys[I],
+        FilterOutNever<{
+          [J in keyof Values]: Values[J] extends {
+            key: Keys[I];
+          }
+            ? Values[J]
+            : never;
+        }>
+      >;
+    }
+  : never;
+
+type CreateRecordFromMeta<Ts, MF extends DeepMergeMergeFunctionsURIs, 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>
+          : never;
+      }>
+    : never;
+
+type CreateRecordForKeyFromMeta<
+  Key extends PropertyKey,
+  Values extends ReadonlyArray<unknown>,
+  Optional extends boolean,
+  MF extends DeepMergeMergeFunctionsURIs,
   M,
-> = FilterOutNever<
-  DeepMergeRecordsDefaultHKTInternalPropValueHelper<Ts, K, M, readonly []>
->;
+> = Optional extends true
+  ? {
+      [k in Key]+?: DeepMergeHKT<Values, MF, M>;
+    }
+  : {
+      [k in Key]-?: DeepMergeHKT<Values, MF, M>;
+    };
 
 /**
- * Tail-recursive helper type for DeepMergeRecordsDefaultHKTInternalPropValue.
+ * Get the possible types of a property.
  */
-type DeepMergeRecordsDefaultHKTInternalPropValueHelper<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>],
-  K extends PropertyKey,
-  M,
-  Acc extends ReadonlyArray<unknown>,
+type DeepMergeRecordPropertyMetaDefaultHKTGetPossible<
+  Key extends PropertyKey,
+  Ts,
 > = Ts extends readonly [
-  infer Head extends Readonly<Record<PropertyKey, unknown>>,
+  RecordPropertyMeta,
+  ...ReadonlyArray<RecordPropertyMeta>,
+]
+  ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
+      Ts,
+      { key: Key; values: []; optional: never }
+    >
+  : never;
+
+/**
+ * Tail-recursive helper type for DeepMergeRecordPropertyMetaDefaultHKTGetPossible.
+ */
+type DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
+  Ts extends readonly [
+    RecordPropertyMeta,
+    ...ReadonlyArray<RecordPropertyMeta>,
+  ],
+  Acc extends {
+    key: PropertyKey;
+    values: ReadonlyArray<unknown>;
+    optional: boolean;
+  },
+> = Ts extends [
   ...infer Rest,
+  {
+    key: infer K extends PropertyKey;
+    value: infer V;
+    optional: infer O extends boolean;
+  },
 ]
-  ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>]
-    ? DeepMergeRecordsDefaultHKTInternalPropValueHelper<
-        Rest,
-        K,
-        M,
-        [...Acc, ValueOfKey<Head, K>]
-      >
-    : [...Acc, ValueOfKey<Head, K>]
+  ? Acc["optional"] extends true
+    ? Acc extends { values: [infer Head, ...infer AccRest] }
+      ? Rest extends readonly [
+          RecordPropertyMeta,
+          ...ReadonlyArray<RecordPropertyMeta>,
+        ]
+        ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
+            Rest,
+            {
+              key: K;
+              values: [V | Head, ...AccRest];
+              optional: O;
+            }
+          >
+        : {
+            key: K;
+            values: [V | Head, ...AccRest];
+            optional: O;
+          }
+      : Rest extends readonly [
+            RecordPropertyMeta,
+            ...ReadonlyArray<RecordPropertyMeta>,
+          ]
+        ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
+            Rest,
+            {
+              key: K;
+              values: [V, ...Acc["values"]];
+              optional: O;
+            }
+          >
+        : {
+            key: K;
+            values: [V, ...Acc["values"]];
+            optional: O;
+          }
+    : Rest extends readonly [
+          RecordPropertyMeta,
+          ...ReadonlyArray<RecordPropertyMeta>,
+        ]
+      ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
+          Rest,
+          {
+            key: K;
+            values: [V, ...Acc["values"]];
+            optional: O;
+          }
+        >
+      : {
+          key: K;
+          values: [V, ...Acc["values"]];
+          optional: O;
+        }
   : never;
 
 /**
- * Deep merge 2 arrays.
+ * Deep merge arrays.
  */
 export type DeepMergeArraysDefaultHKT<
   Ts extends ReadonlyArray<unknown>,
@@ -142,14 +278,14 @@ type DeepMergeArraysDefaultHKTHelper<
   : never;
 
 /**
- * Deep merge 2 sets.
+ * Deep merge sets.
  */
 export type DeepMergeSetsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Set<
   UnionSetValues<Ts>
 >;
 
 /**
- * Deep merge 2 maps.
+ * Deep merge maps.
  */
 export type DeepMergeMapsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Map<
   UnionMapKeys<Ts>,
diff --git a/src/types/utils.ts b/src/types/utils.ts
index e927409e..e2f85ff6 100644
--- a/src/types/utils.ts
+++ b/src/types/utils.ts
@@ -2,19 +2,29 @@
  * Flatten a complex type such as a union or intersection of objects into a
  * single object.
  */
-export type FlatternAlias<T> = T extends {} ? FlatternRecord<T> : T;
+export type FlatternAlias<T> = T extends {} ? FlattenRecord<T> : T;
 
-type FlatternRecord<T extends {}> = {
+type FlattenRecord<T extends {}> = {
   [K in keyof T]: T[K];
 } & {};
 
 /**
- * Get the value of the given key in the given object.
+ * Flatten a collection of tuples of tuples into a collection of tuples.
  */
-export type ValueOfKey<
-  T extends Record<PropertyKey, unknown>,
-  K extends PropertyKey,
-> = K extends keyof T ? T[K] : never;
+export type FlattenTuples<T> = {
+  [I in keyof T]: FlattenTuple<T[I]>;
+};
+
+/**
+ * Flatten a tuple of tuples into a single tuple.
+ */
+export type FlattenTuple<T> = T extends readonly []
+  ? []
+  : T extends readonly [infer T0]
+    ? [...FlattenTuple<T0>]
+    : T extends readonly [infer T0, ...infer Ts]
+      ? [...FlattenTuple<T0>, ...FlattenTuple<Ts>]
+      : [T];
 
 /**
  * Safely test whether or not the first given types extends the second.
@@ -28,6 +38,25 @@ export type Is<T1, T2> = [T1] extends [T2] ? true : false;
  */
 export type IsNever<T> = Is<T, never>;
 
+/**
+ * And operator for types.
+ */
+export type And<T1 extends boolean, T2 extends boolean> = T1 extends false
+  ? false
+  : T2;
+
+/**
+ * Or operator for types.
+ */
+export type Or<T1 extends boolean, T2 extends boolean> = T1 extends true
+  ? true
+  : T2;
+
+/**
+ * Not operator for types.
+ */
+export type Not<T extends boolean> = T extends true ? false : true;
+
 /**
  * Returns whether or not all the given types are never.
  */
@@ -130,25 +159,6 @@ export type EveryIsMap<Ts extends ReadonlyArray<unknown>> =
         : false
       : false;
 
-/**
- * And operator for types.
- */
-export type And<T1 extends boolean, T2 extends boolean> = T1 extends false
-  ? false
-  : T2;
-
-/**
- * Or operator for types.
- */
-export type Or<T1 extends boolean, T2 extends boolean> = T1 extends true
-  ? true
-  : T2;
-
-/**
- * Not operator for types.
- */
-export type Not<T extends boolean> = T extends true ? false : true;
-
 /**
  * Union of the sets' values' types
  */
@@ -209,92 +219,11 @@ type UnionMapValuesHelper<
     : never
   : Acc;
 
-/**
- * Get all the keys of the given records.
- */
-export type KeysOf<Ts extends ReadonlyArray<unknown>> = KeysOfHelper<Ts, never>;
-
-/**
- * Tail-recursive helper type for KeysOf.
- */
-type KeysOfHelper<
-  Ts extends ReadonlyArray<unknown>,
-  Acc,
-> = Ts extends readonly [infer Head, ...infer Rest]
-  ? Head extends Record<PropertyKey, unknown>
-    ? Rest extends ReadonlyArray<unknown>
-      ? KeysOfHelper<Rest, Acc | keyof Head>
-      : Acc | keyof Head
-    : never
-  : Acc;
-
-/**
- * Get the keys of the type what match a certain criteria.
- */
-type KeysOfType<T, U> = {
-  [K in keyof T]: T[K] extends U ? K : never;
-}[keyof T];
-
-/**
- * Get the required keys of the type.
- */
-type RequiredKeys<T> = Exclude<
-  KeysOfType<T, Exclude<T[keyof T], undefined>>,
-  undefined
->;
-
-/**
- * Get all the required keys on the types in the tuple.
- */
-export type RequiredKeysOf<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>],
-> = RequiredKeysOfHelper<Ts, never>;
-
-/**
- * Tail-recursive helper type for RequiredKeysOf.
- */
-type RequiredKeysOfHelper<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>],
-  Acc,
-> = Ts extends readonly [infer Head, ...infer Rest]
-  ? Head extends Record<PropertyKey, unknown>
-    ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>]
-      ? RequiredKeysOfHelper<Rest, Acc | RequiredKeys<Head>>
-      : Acc | RequiredKeys<Head>
-    : never
-  : Acc;
-
-/**
- * Get the optional keys of the type.
- */
-type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
-
-/**
- * Get all the optional keys on the types in the tuple.
- */
-export type OptionalKeysOf<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>],
-> = OptionalKeysOfHelper<Ts, never>;
-
-/**
- * Tail-recursive helper type for OptionalKeysOf.
- */
-type OptionalKeysOfHelper<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>],
-  Acc,
-> = Ts extends readonly [infer Head, ...infer Rest]
-  ? Head extends Record<PropertyKey, unknown>
-    ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>]
-      ? OptionalKeysOfHelper<Rest, Acc | OptionalKeys<Head>>
-      : Acc | OptionalKeys<Head>
-    : never
-  : Acc;
-
 /**
  * Filter out nevers from a tuple.
  */
-export type FilterOutNever<T extends ReadonlyArray<unknown>> =
-  FilterOutNeverHelper<T, []>;
+export type FilterOutNever<T> =
+  T extends ReadonlyArray<unknown> ? FilterOutNeverHelper<T, []> : never;
 
 /**
  * Tail-recursive helper type for FilterOutNever.
@@ -318,3 +247,75 @@ export type IsTuple<T extends ReadonlyArray<unknown>> = T extends readonly []
   : T extends readonly [unknown, ...ReadonlyArray<unknown>]
     ? true
     : false;
+
+/**
+ * Perfrom a transpose operation on a 2D tuple.
+ */
+export type TransposeTuple<T> = T extends readonly [
+  ...(readonly [...unknown[]]),
+]
+  ? T extends readonly []
+    ? []
+    : T extends readonly [infer X extends ReadonlyArray<unknown>]
+      ? TransposeTupleSimpleCase<X>
+      : T extends readonly [
+            infer X extends ReadonlyArray<unknown>,
+            ...infer XS extends ReadonlyArray<ReadonlyArray<unknown>>,
+          ]
+        ? PrependCol<X, TransposeTuple<XS>>
+        : T
+  : never;
+
+type PrependCol<
+  T extends ReadonlyArray<unknown>,
+  S extends ReadonlyArray<ReadonlyArray<unknown>>,
+> = T extends readonly []
+  ? S extends readonly []
+    ? []
+    : never
+  : T extends readonly [infer X, ...infer XS]
+    ? S extends readonly [
+        readonly [...infer Y],
+        ...infer YS extends ReadonlyArray<ReadonlyArray<unknown>>,
+      ]
+      ? [[X, ...Y], ...PrependCol<XS, YS>]
+      : never
+    : never;
+
+type TransposeTupleSimpleCase<T extends readonly [...unknown[]]> =
+  T extends readonly []
+    ? []
+    : T extends readonly [infer X, ...infer XS]
+      ? [[X], ...TransposeTupleSimpleCase<XS>]
+      : never;
+
+/**
+ * Convert a tuple to an intersection of each of its types.
+ */
+export type TupleToIntersection<T extends ReadonlyArray<unknown>> =
+  {
+    [K in keyof T]: (x: T[K]) => void;
+  } extends Record<number, (x: infer I) => void>
+    ? I
+    : never;
+
+/**
+ * Convert a union to a tuple.
+ *
+ * Warning: The order of the elements is non-deterministic.
+ * Warning 2: The union maybe me modified by the TypeScript engine before convertion.
+ * Warning 3: This implementation relies on a hack/limitation in TypeScript.
+ */
+export type TuplifyUnion<T, L = LastOf<T>> =
+  IsNever<T> extends true ? [] : [...TuplifyUnion<Exclude<T, L>>, L];
+
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I,
+) => void
+  ? I
+  : never;
+
+type LastOf<T> =
+  UnionToIntersection<T extends any ? () => T : never> extends () => infer R
+    ? R
+    : never;
diff --git a/tests/deepmerge-into.test-d.ts b/tests/deepmerge-into.test-d.ts
index c8baac1c..62f5b1ab 100644
--- a/tests/deepmerge-into.test-d.ts
+++ b/tests/deepmerge-into.test-d.ts
@@ -81,3 +81,17 @@ expectAssignable<{
   bar: "123";
   quux: "456";
 }>(test6);
+
+const d: { waldo: boolean; fred?: number } = { waldo: false };
+
+const test7 = { ...a };
+deepmergeInto(test7, d);
+expectAssignable<{
+  foo: string;
+  baz: {
+    quux: string[];
+  };
+  garply: number;
+  waldo: boolean;
+  fred?: number;
+}>(test7);
diff --git a/tests/deepmerge.test-d.ts b/tests/deepmerge.test-d.ts
index 0fcaad12..f0a62cdd 100644
--- a/tests/deepmerge.test-d.ts
+++ b/tests/deepmerge.test-d.ts
@@ -228,3 +228,14 @@ const test16 = deepmerge(first, second, third, fourth);
 expectType<{ first: boolean; second: boolean; third: number; fourth: string }>(
   test16,
 );
+
+const n: { a: true; b: string } = { a: true, b: "n" };
+const o: { a: false; b?: number } = { a: false };
+
+const test17 = deepmerge(n, o);
+expectType<{ a: false; b: string | number }>(test17);
+
+const p: { a: true; b?: string } = { a: true, b: "n" };
+
+const test18 = deepmerge(o, p);
+expectType<{ a: true; b?: string | number }>(test18);