refactor(values-of): more consistent type inference

Author: pevisscher

src/object/values-of/values-of.spec.ts

@@ -2,7 +2,7 @@ import { valuesOf } from './index.js'
 
 import { forAll, record, unknown, string, array, oneOf, integer } from '../../random/index.js'
 
-import { expect, it } from 'vitest'
+import { expect, it, expectTypeOf } from 'vitest'
 
 it('valuesOf === Object.values', () => {
     forAll(record(unknown()), (o) => {
@@ -30,8 +30,12 @@ it('valuesOf union object and array', () => {
     forAll(oneOf(array(string()), record([integer(), integer()])), (o) => {
         expect(valuesOf(o)).toStrictEqual(Object.values(o))
     })
-    const _foo: number[] = valuesOf([1, 2, 3])
-    const _foo2: (number | string)[] = valuesOf([1, '2', 3])
-    const _foo3: 'bar'[] = valuesOf({ foo: 'bar' } as const)
-    const _foo4: number[] | string[] = valuesOf<number[] | { foo: string }>({ foo: 'bar' })
+})
+
+it('types', () => {
+    expectTypeOf(valuesOf({ foo: 'bar' })).toEqualTypeOf<'bar'[]>()
+    expectTypeOf(valuesOf<number[] | { foo: string }>({ foo: 'bar' })).toEqualTypeOf<number[] | string[]>()
+
+    expectTypeOf(valuesOf([1, 2, 3])).toEqualTypeOf<(1 | 2 | 3)[]>()
+    expectTypeOf(valuesOf([1, '2', 3])).toEqualTypeOf<(1 | '2' | 3)[]>()
 })

src/object/values-of/values-of.ts

@@ -1,6 +1,4 @@
-import type { KeyOf } from '../../type/index.js'
-
-export type ValuesOf<T> = T extends (infer I)[] ? I[] : T[KeyOf<T>][]
+export type ValuesOf<T extends ArrayLike<unknown> | {}> = T extends readonly (infer I)[] ? I[] : T[keyof T][]
 
 /**
  * Returns an array of values of the enumerable properties of an object.
@@ -23,6 +21,6 @@ export type ValuesOf<T> = T extends (infer I)[] ? I[] : T[KeyOf<T>][]
  *
  * @group Object
  */
-export function valuesOf<T extends ArrayLike<unknown> | {}>(obj: T): ValuesOf<T> {
+export function valuesOf<const T extends ArrayLike<unknown> | {}>(obj: T): ValuesOf<T> {
     return Object.values(obj) as ValuesOf<T>
 }