Generic enum typeguard

I want to write a generic type guard for enums but this doesn't work so far in TS 5.0.4

function isEnumValue<T>(enumType: T, value: unknown): value is T[keyof T] {
  return Object.values(enumType).includes(value as T[keyof T]);
}
//-----------------------^--------------------------
//             No overload matches this call

enum Sort {
  A,
  B
}
function isSort(value: unknown): value is Sort {
  return isEnumValue(Sort, value);
}

enum Order {
  ASC,
  DESC
}
function isOrder(value: unknown): value is Order {
  return isEnumValue(Order, value);
}

Playground

Maybe I can have a hint ?

I'm going to assume that you just want to resolve the "no overload matches this call" error and that the implementation of the function works as you intend at runtime... even though numeric enums have reverse mappings where Object.values(enumType).includes(value) will give a false positive when value is one of the enum keys. There are ways to work around that but I'm considering this out of scope here.

The problem you're running into is that your generic type parameter T is not constrained, and therefore could be any type at all, including those with null or undefined in their domain. And so the enumType parameter can be of such a type.

But the TypeScript library typings for the Object.values() method are like

interface ObjectConstructor {      
  values<T>(o: { [s: string]: T } | ArrayLike<T>): T[];
  values(o: {}): any[];
}

where the parameter must at least be assignable to the type {}, which allows just about anything except for null and undefined. See https://stackoverflow.com/q/59135229/2887218 for more information.

So neither of the two call signatures for Object.values() shown above is appropriate. T is certainly not constrained to {[s: string]: unknown} | ArrayLike<unknown>} as needed for the first call signature, and it is not constrained to {} as needed for the second call signature.

In other words: since nothing stops someone from calling

isEnumValue(null, "a"); 

the compiler doesn't want to let you pass enumType into Object.values()

The fix for this is therefore to constrain T to be the non-nullable {} type:

function isEnumValue<T extends {}>(enumType: T, value: unknown): value is T[keyof T] {
  return Object.values(enumType).includes(value as T[keyof T]); // okay
}

This works because now isEnumValue() cannot be called with a possibly-nullish enumType argument. If you call isEnumValue(null, "a") you'll get a compiler error at the call site:

isEnumValue(null, "a"); // error
// Argument of type 'null' is not assignable to parameter of type '{}'.

Looks good!

Playground link to code