fix(core): remove unnecessary conditional type in `RequiredCompareKey…

…s` (#56) * fix(core): remove unnecessary conditional type in `RequiredCompareKeys`, fix base using type in `OptionalCompareKeys` * fix type using object mapping to union extends Co-authored-by: L2HYUNN <[email protected]>
toss · Sep 17, 2024 · 0af3a1a · 0af3a1a
1 parent 3369bc9
commit 0af3a1a
Show file tree

Hide file tree

Showing 3 changed files with 141 additions and 14 deletions.
diff --git a/packages/core/package.json b/packages/core/package.json
@@ -22,8 +22,8 @@
     "package.json"
   ],
   "scripts": {
-    "test": "vitest run",
-    "test:unit": "vitest --root test/",
+    "test": "vitest run --typecheck",
+    "test:unit": "vitest --typecheck --root test/",
     "build": "rimraf dist && concurrently \"pnpm:build:*\"",
     "build:dist": "tsup",
     "build:types": "tsc -p tsconfig.build.json --emitDeclarationOnly",

diff --git a/packages/core/src/typeUtil.ts b/packages/core/src/typeUtil.ts
@@ -1,28 +1,26 @@
-export type Prettify<T> = { [K in keyof T]: T[K] } & {};
+export type Prettify<T> = Omit<T, never>;
 /**
  * Extracts the keys that are required when converting from TBase to TResult.
  * @example RequiredCompareKeys<{a: string, b?: string}, {a: string, b: string}> // 'b'
  */
-export type RequiredCompareKeys<TBase, TResult> = {
-  [K in keyof TBase | keyof TResult]: K extends keyof TResult
+export type RequiredCompareKeys<TBase, TResult> = keyof TResult | keyof TBase extends infer K
+  ? K extends keyof TResult
     ? K extends keyof TBase
       ? TBase[K] extends TResult[K]
         ? never
         : K
       : undefined extends TResult[K]
         ? never
         : K
-    : K extends keyof TBase
-      ? never
-      : never;
-}[keyof TBase | keyof TResult];
+    : never
+  : never;
 
 /**
  * Extracts the keys that are optional when converting from TBase to TResult.
  * @example OptionalCompareKeys<{a: string, b?: string}, {a: string, b: string}> // 'a'
  */
-type OptionalCompareKeys<TBase, TResult> = {
-  [K in keyof TBase | keyof TResult]: K extends keyof TResult
+export type OptionalCompareKeys<TBase, TResult> = keyof TBase | keyof TResult extends infer K
+  ? K extends keyof TResult
     ? K extends keyof TBase
       ? TBase[K] extends TResult[K]
         ? K
@@ -31,9 +29,9 @@ type OptionalCompareKeys<TBase, TResult> = {
         ? K
         : never
     : K extends keyof TBase
-      ? never
-      : never;
-}[keyof TBase | keyof TResult];
+      ? K
+      : never
+  : never;
 
 /**
  * Compares TBase with TResult to create a new object that uses TResult's values for required keys,

diff --git a/packages/core/test/typeUtil.test-d.tsx b/packages/core/test/typeUtil.test-d.tsx
@@ -0,0 +1,129 @@
+import { describe, expectTypeOf, test } from 'vitest';
+import { CompareMergeContext, OptionalCompareKeys, RequiredCompareKeys } from '../src/typeUtil';
+
+describe('typeUtil test', () => {
+  describe('RequiredCompareKeys', () => {
+    describe('When TBase has optional keys and TResult has compare required key', () => {
+      test('Should return the keys that are required when converting from TBase to TResult', () => {
+        type Result = RequiredCompareKeys<{ a: string; b?: string }, { a: string; b: string }>;
+        expectTypeOf<Result>().toEqualTypeOf<'b'>();
+      });
+    });
+
+    describe('When TBase has no key and TResult has compare required key', () => {
+      test('Should return the keys that are required when converting from TBase to TResult', () => {
+        type Result = RequiredCompareKeys<{ a: string }, { a: string; b: string }>;
+        expectTypeOf<Result>().toEqualTypeOf<'b'>();
+      });
+    });
+
+    describe('When TBase has no keys', () => {
+      test('Should return the keys that are required when converting from TBase to TResult', () => {
+        type Result = RequiredCompareKeys<{}, { a: string; b: string }>;
+        expectTypeOf<Result>().toEqualTypeOf<'a' | 'b'>();
+      });
+    });
+
+    describe('When TBase and TResult have no keys', () => {
+      test('Should return the never', () => {
+        type Result = RequiredCompareKeys<{}, {}>;
+        expectTypeOf<Result>().toEqualTypeOf<never>();
+      });
+    });
+
+    describe('When TBase and TResult have the same type', () => {
+      test('Should return the never', () => {
+        type Result = RequiredCompareKeys<{ a: string; b: string }, { a: string; b: string }>;
+        expectTypeOf<Result>().toEqualTypeOf<never>();
+      });
+    });
+  });
+
+  describe('OptionalCompareKeys', () => {
+    describe('When TBase has optional keys and TResult has compare required key', () => {
+      test('Should return the keys that are optional when converting from TBase to TResult', () => {
+        type Result = OptionalCompareKeys<{ a: string; b?: string }, { a: string; b: string }>;
+        expectTypeOf<Result>().toEqualTypeOf<'a'>();
+      });
+    });
+
+    describe('When TBase has no key and TResult has compare required key', () => {
+      test('Should return the keys that are optional when converting from TBase to TResult', () => {
+        type Result = OptionalCompareKeys<{ a: string }, { a: string; b: string }>;
+        expectTypeOf<Result>().toEqualTypeOf<'a'>();
+      });
+    });
+
+    describe('When TBase has no keys', () => {
+      test('Should return the never', () => {
+        type Result = OptionalCompareKeys<{}, { a: string; b: string }>;
+        expectTypeOf<Result>().toEqualTypeOf<never>();
+      });
+    });
+
+    describe('When TBase and TResult have no keys', () => {
+      test('Should return the never', () => {
+        type Result = OptionalCompareKeys<{}, {}>;
+        expectTypeOf<Result>().toEqualTypeOf<never>();
+      });
+    });
+
+    describe('When TBase and TResult have the same type', () => {
+      test('Should return all key', () => {
+        type Result = OptionalCompareKeys<{ a: string; b: string }, { a: string; b: string }>;
+        expectTypeOf<Result>().toEqualTypeOf<'a' | 'b'>();
+      });
+    });
+
+    describe('When TBase has required keys and TResult compare nothing key', () => {
+      test('Should return the TBase keys', () => {
+        type Result = OptionalCompareKeys<{ a: string; b: string }, { c: number }>;
+        expectTypeOf<Result>().toEqualTypeOf<'a' | 'b'>();
+      });
+    });
+  });
+
+  describe('CompareMergeContext', () => {
+    describe('When TBase has optional keys and TResult has compare required key', () => {
+      test('Should return the new object that uses TResult values for required keys, and TBase values for optional keys', () => {
+        type Result = CompareMergeContext<{ a: string; b?: string }, { a: string; b: string }>;
+        expectTypeOf<Result>().toEqualTypeOf<{ a?: string; b: string }>();
+      });
+    });
+
+    describe('When TBase has no key and TResult has compare required key', () => {
+      test('Should return the new object that uses TResult values for required keys, and TBase values for optional keys', () => {
+        type Result = CompareMergeContext<{ a: string }, { a: string; b: string }>;
+        expectTypeOf<Result>().toEqualTypeOf<{ a?: string; b: string }>();
+      });
+    });
+
+    describe('When TBase has no keys', () => {
+      test('Should return the TResult type', () => {
+        type Result = CompareMergeContext<{}, { a: string; b: string }>;
+        expectTypeOf<Result>().toEqualTypeOf<{ a: string; b: string }>();
+      });
+    });
+
+    describe('When TBase and TResult have no keys', () => {
+      test('Should return the empty object', () => {
+        type Result = CompareMergeContext<{}, {}>;
+        expectTypeOf<Result>().toEqualTypeOf<{}>();
+      });
+    });
+
+    describe('When TBase and TResult have the same type', () => {
+      test('Should return the new object patial object for that types', () => {
+        type Result = CompareMergeContext<{ a: string; b: string }, { a: string; b: string }>;
+        expectTypeOf<Result>().toEqualTypeOf<{ a?: string; b?: string }>();
+      });
+    });
+
+    describe('When TBase has required keys and TResult compare nothing key', () => {
+      test('Should return the new object that uses TResult values for required keys, and TBase values for optional keys', () => {
+        type Result = CompareMergeContext<{ a: string; b: string }, { c: number }>;
+        expectTypeOf<Result>().toEqualTypeOf<{ a?: string; b?: string; c: number }>();
+      });
+    });
+  });
+});