From 244823e3a7d40323b87e9846b6ac272763ee6ec9 Mon Sep 17 00:00:00 2001
From: Alec Larson <1925840+aleclarson@users.noreply.github.com>
Date: Tue, 9 Jul 2024 16:17:37 -0400
Subject: [PATCH] chore: tweak ExtractArray/Map/Set types

---
 src/typed/isArray.ts | 17 +++++++++++------
 src/typed/isMap.ts   | 16 ++++++++--------
 src/typed/isSet.ts   | 17 +++++++++++------
 3 files changed, 30 insertions(+), 20 deletions(-)

diff --git a/src/typed/isArray.ts b/src/typed/isArray.ts
index 9433de39..59545007 100644
--- a/src/typed/isArray.ts
+++ b/src/typed/isArray.ts
@@ -4,12 +4,17 @@ export const isArray = Array.isArray as <Input>(
   value: Input,
 ) => value is ExtractArray<Input>
 
-export type ExtractArray<Input> = Input extends any
-  ? [StrictExtract<Input, readonly any[]>] extends [readonly any[]]
-    ? Extract<Input, readonly any[]>
-    : [StrictExtract<Input, any[]>] extends [any[]]
-      ? Extract<Input, any[]>
-      : unknown[] extends Input
+/**
+ * An absurdly complicated but accurate type for extracting Array types.
+ *
+ * It's like `Extract<T, any[]>` but better with edge cases.
+ */
+export type ExtractArray<T> = T extends any
+  ? [StrictExtract<T, readonly any[]>] extends [readonly any[]]
+    ? Extract<T, readonly any[]>
+    : [StrictExtract<T, any[]>] extends [any[]]
+      ? Extract<T, any[]>
+      : unknown[] extends T
         ? unknown[]
         : never
   : never
diff --git a/src/typed/isMap.ts b/src/typed/isMap.ts
index 06759a2d..ec08385e 100644
--- a/src/typed/isMap.ts
+++ b/src/typed/isMap.ts
@@ -6,17 +6,17 @@ export function isMap<Input>(value: Input): value is ExtractMap<Input> {
 
 /**
  * An absurdly complicated but accurate type for extracting Map types.
+ *
+ * It's like `Extract<T, Map<any, any>>` but better with edge cases.
  */
-export type ExtractMap<Input> = Input extends any
-  ? [StrictExtract<Input, ReadonlyMap<unknown, unknown>>] extends [
+export type ExtractMap<T> = T extends any
+  ? [StrictExtract<T, ReadonlyMap<unknown, unknown>>] extends [
       ReadonlyMap<unknown, unknown>,
     ]
-    ? Extract<Input, ReadonlyMap<unknown, unknown>>
-    : [StrictExtract<Input, Map<unknown, unknown>>] extends [
-          Map<unknown, unknown>,
-        ]
-      ? Extract<Input, Map<unknown, unknown>>
-      : Map<unknown, unknown> extends Input
+    ? Extract<T, ReadonlyMap<unknown, unknown>>
+    : [StrictExtract<T, Map<unknown, unknown>>] extends [Map<unknown, unknown>]
+      ? Extract<T, Map<unknown, unknown>>
+      : Map<unknown, unknown> extends T
         ? Map<unknown, unknown>
         : never
   : never
diff --git a/src/typed/isSet.ts b/src/typed/isSet.ts
index b1159a32..b350cdd2 100644
--- a/src/typed/isSet.ts
+++ b/src/typed/isSet.ts
@@ -4,12 +4,17 @@ export function isSet<Input>(value: Input): value is ExtractSet<Input> {
   return isTagged(value, '[object Set]')
 }
 
-export type ExtractSet<Input> = Input extends any
-  ? [StrictExtract<Input, ReadonlySet<unknown>>] extends [ReadonlySet<unknown>]
-    ? Extract<Input, ReadonlySet<unknown>>
-    : [StrictExtract<Input, Set<unknown>>] extends [Set<unknown>]
-      ? Extract<Input, Set<unknown>>
-      : Set<unknown> extends Input
+/**
+ * An absurdly complicated but accurate type for extracting Set types.
+ *
+ * It's like `Extract<T, Set<any>>` but better with edge cases.
+ */
+export type ExtractSet<T> = T extends any
+  ? [StrictExtract<T, ReadonlySet<unknown>>] extends [ReadonlySet<unknown>]
+    ? Extract<T, ReadonlySet<unknown>>
+    : [StrictExtract<T, Set<unknown>>] extends [Set<unknown>]
+      ? Extract<T, Set<unknown>>
+      : Set<unknown> extends T
         ? Set<unknown>
         : never
   : never