Argument of type 'string' is not assignable to parameter of type union of string consts

user_2957660 0
Viewed 572

Once again I'm here seeking for some guidance on Typescript heuristics. I'm having trouble writing a type guard because Typescript wants to be too narrow when it comes to comparing.

Consider the following scenario (or the Typescript Playground):

const FOO = 'foo' as const;
const BAR = 'bar' as const;

const ALL_THINGS = [FOO, BAR];
type AllThingsType = typeof ALL_THINGS[number];

function isAllThings(value: unknown): value is AllThingsType {
  return typeof value === 'string' && ALL_THINGS.includes(value);
}

The error will be the following one:

Argument of type 'string' is not assignable to parameter of type '"foo" | "bar"'.ts(2345)

There is technically a way of working around this:

function isAllThingsWorkaround(value: unknown): value is AllThingsType {
  return typeof value === 'string' && (ALL_THINGS as string[]).includes(value);
}

Am I missing something in regards to how I should do this? The snippet I shared is a simplified version, you can assume that ALL_THINGS is actually a collection of almost 25 consts. How could I improve this in order to avoid the workaround?

Thanks for the help!

typescript-typings typescript
1 Answers

One way you could do this is to not use .includes.

const FOO = 'foo' as const;
const BAR = 'bar' as const;

const ALL_THINGS = [FOO, BAR];
type AllThingsType = typeof ALL_THINGS[number];

function isAllThings(value: unknown): value is AllThingsType {
  return typeof value === 'string' && ALL_THINGS.find(a => a === value) !== undefined;
}

console.log(isAllThings("cat")); // false
console.log(isAllThings("foo")); // true

This way does not require type casting, and you get to decide what "includes" actually means, rather than letting javascript decide.

user_128335530
Related