fix(types): handle tuples in isArray return type

Author: aleclarson

src/typed/isArray.ts

@@ -1,11 +1,15 @@
-import type { ExtractNotAny } from 'radashi'
+import type { StrictExtract } from 'radashi'
 
 export const isArray = Array.isArray as <Input>(
   value: Input,
-) => value is readonly any[] extends ExtractNotAny<Input, readonly any[]>
-  ? Extract<Input, readonly any[]>
-  : any[] extends ExtractNotAny<Input, any[]>
-    ? Extract<Input, any[]>
-    : unknown[] extends Input
-      ? unknown[]
-      : never
+) => 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
+        ? unknown[]
+        : never
+  : never

src/typed/isMap.ts

@@ -1,18 +1,22 @@
-import { type ExtractNotAny, isTagged } from 'radashi'
+import { isTagged, type StrictExtract } from 'radashi'
 
-export function isMap<Input>(
-  value: Input,
-): value is ReadonlyMap<any, any> extends ExtractNotAny<
-  Input,
-  ReadonlyMap<any, any>
->
-  ? Extract<Input, ReadonlyMap<unknown, unknown>>
-  : Map<any, any> extends ExtractNotAny<Input, Map<any, any>>
-    ? Extract<Input, Map<unknown, unknown>>
-    : Map<unknown, unknown> extends Input
-      ? Map<unknown, unknown>
-      : never
-
-export function isMap(value: unknown): boolean {
+export function isMap<Input>(value: Input): value is ExtractMap<Input> {
   return isTagged(value, '[object Map]')
 }
+
+/**
+ * An absurdly complicated but accurate type for extracting Map types.
+ */
+export type ExtractMap<Input> = Input extends any
+  ? [StrictExtract<Input, 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
+        ? Map<unknown, unknown>
+        : never
+  : never

src/typed/isSet.ts

@@ -1,15 +1,15 @@
-import { type ExtractNotAny, isTagged } from 'radashi'
+import { isTagged, type StrictExtract } from 'radashi'
 
-export function isSet<Input>(
-  value: Input,
-): value is ReadonlySet<any> extends ExtractNotAny<Input, ReadonlySet<any>>
-  ? Extract<Input, ReadonlySet<unknown>>
-  : Set<any> extends ExtractNotAny<Input, Set<any>>
-    ? Extract<Input, Set<unknown>>
-    : Set<unknown> extends Input
-      ? Set<unknown>
-      : never
-
-export function isSet(value: unknown): boolean {
+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
+        ? Set<unknown>
+        : never
+  : never

src/types.ts

@@ -23,3 +23,15 @@ export declare class Any {
  * ```
  */
 export type ExtractNotAny<T, U> = Extract<[T] extends [Any] ? never : T, U>
+
+export type SwitchAny<T, U> = [T] extends [Any] ? U : T
+export type SwitchNever<T, U> = [T] extends [never] ? U : T
+
+/**
+ * Extract types in `T` that are assignable to `U`. Coerce `any` and
+ * `never` types to unknown.
+ */
+export type StrictExtract<T, U> = SwitchNever<
+  Extract<SwitchAny<T, unknown>, U>,
+  unknown
+>

tests/typed/isArray.test-d.ts

@@ -17,6 +17,14 @@ describe('isArray return type', () => {
       expectTypeOf(value).toEqualTypeOf<unknown>()
     }
   })
+  test('value is never', () => {
+    const value = {} as never
+    if (_.isArray(value)) {
+      expectTypeOf(value).toEqualTypeOf<never>()
+    } else {
+      expectTypeOf(value).toEqualTypeOf<never>()
+    }
+  })
   test('value is string', () => {
     const value = {} as string
     if (_.isArray(value)) {
@@ -25,28 +33,36 @@ describe('isArray return type', () => {
       expectTypeOf(value).toEqualTypeOf<string>()
     }
   })
-  test('value is string or ReadonlyMap', () => {
+  test('value is string or readonly string[]', () => {
     const value = {} as string | readonly string[]
     if (_.isArray(value)) {
       expectTypeOf(value).toEqualTypeOf<readonly string[]>()
     } else {
       expectTypeOf(value).toEqualTypeOf<string>()
     }
   })
-  test('value is string, ReadonlyMap, or Map', () => {
+  test('value is string, readonly string[], or string[]', () => {
     const value = {} as string | readonly string[] | string[]
     if (_.isArray(value)) {
       expectTypeOf(value).toEqualTypeOf<readonly string[] | string[]>()
     } else {
       expectTypeOf(value).toEqualTypeOf<string>()
     }
   })
-  test('value is string or Map', () => {
+  test('value is string or string[]', () => {
     const value = {} as string | string[]
     if (_.isArray(value)) {
       expectTypeOf(value).toEqualTypeOf<string[]>()
     } else {
       expectTypeOf(value).toEqualTypeOf<string>()
     }
   })
+  test('value is readonly [number, number] | number', () => {
+    const value = {} as readonly [number, number] | number
+    if (_.isArray(value)) {
+      expectTypeOf(value).toEqualTypeOf<readonly [number, number]>()
+    } else {
+      expectTypeOf(value).toEqualTypeOf<number>()
+    }
+  })
 })