TypeScript type ignore case

NEW ANSWER FOR TYPESCRIPT 4.1+

Welcome back! Now that TypeScript 4.1 has introduced template literal types and the Uppercase/Lowercase intrinsic string mapping types, we can now answer this question without needing regular expression types.

There are two main approaches. The "brute force" approach makes heavy use of recursive conditional types and unions to turn your xhrTypes into a concrete union of all possible ways of writing those strings where case doesn't matter:

type xhrTypes = "GET" | "POST" | "PUT" | "DELETE" | "OPTIONS" | "CONNECT" | "HEAD";type AnyCase<T extends string> =    string extends T ? string :    T extends `${infer F1}${infer F2}${infer R}` ? (        `${Uppercase<F1> | Lowercase<F1>}${Uppercase<F2> | Lowercase<F2>}${AnyCase<R>}`    ) :    T extends `${infer F}${infer R}` ? `${Uppercase<F> | Lowercase<F>}${AnyCase<R>}` :    ""type AnyCaseXhrTypes = AnyCase<xhrTypes>;

If you inspect AnyCaseXhrTypes, you'll see that it is a 368-member union:

/* type AnyCaseXhrTypes = "GET" | "POST" | "PUT" | "DELETE" | "OPTIONS" | "CONNECT" | "HEAD" | "GEt" | "GeT" | "Get" | "gET" | "gEt" | "geT" | "get" | "POSt" | "POsT" | "POst" | "PoST" |  "PoSt" | "PosT" | "Post" | ... 346 more ... | "head" */

You can then use this type in place of xhrType wherever you want case insensitivity:

function acceptAnyCaseXhrType(xhrType: AnyCaseXhrTypes) { }acceptAnyCaseXhrType("get"); // okayacceptAnyCaseXhrType("DeLeTe"); // okayacceptAnyCaseXhrType("poot"); // error! "poot" not assignable to big union

The problem with the brute force approach is that it doesn't scale well with more or longer strings. Union types in TypeScript are limited to 100,000 members, and recursive conditional types only really go about 20 levels deep maximum before the compiler complains. So any moderately long words or moderately long list of words will make the above approach unfeasible.

type xhrTypes = "GET" | "POST" | "PUT" | "DELETE" | "OPTIONS" | "CONNECT" | "HEAD" | "LONG STRINGS MAKE THE COMPILER UNHAPPY";type AnyCaseXhrTypes = AnyCase<xhrTypes>; // error!// Type instantiation is excessively deep and possibly infinite.// Union type is too complex to represent

A way to deal with that is to switch away from using a specific concrete union, and instead switch to a generic type representation. If T is the type of a string value passed to acceptAnyCaseXhrType(), then all we want to do is make sure that Uppercase<T> is assignable to xhrType. This is more of a constraint than a type (although we can't use generic constraints directly to express this):

function acceptAnyCaseXhrTypeGeneric<T extends string>(    xhrType: Uppercase<T> extends xhrTypes ? T : xhrTypes) { }acceptAnyCaseXhrTypeGeneric("get"); // okayacceptAnyCaseXhrTypeGeneric("DeLeTe"); // okayacceptAnyCaseXhrTypeGeneric("poot"); // error! "poot" not assignable to xhrTypes

This solution requires that you pull generic type parameters around in places you might otherwise not need them, but it does scale well.

So, there you go! All we had to do was wait for... (checks notes)... 3 years, and TypeScript delivered!

Playground link to code

Just so there's an answer on this post: No, it is not possible.

Update 5/15/2018: Still not possible. The closest thing, regex-validated string types, was not well-received the most recent time it was proposed at the language design meeting.

As @RyanCavanaugh said, TypeScript doesn't have case-insensitive string literals. [EDIT: I am reminded that there is an existing suggestion for TypeScript to support regexp-validated string literals, which would maybe allow for this, but it is not currently part of the language.]

The only workaround I can think of is to enumerate the most likely variants of those literals (say, all lowercase, init cap) and make a function that can translate between them if needed:

namespace XhrTypes {  function m<T, K extends string, V extends string>(    t: T, ks: K[], v: V  ): T & Record<K | V, V> {    (t as any)[v] = v;    ks.forEach(k => (t as any)[k] = v);    return t as any;  }  function id<T>(t: T): { [K in keyof T]: T[K] } {    return t;  }  const mapping = id(m(m(m(m(m(m(m({},    ["get", "Get"], "GET"), ["post", "Post"], "POST"),    ["put", "Put"], "PUT"), ["delete", "Delete"], "DELETE"),    ["options", "Options"], "OPTIONS"), ["connect", "Connect"], "CONNECT"),    ["head", "Head"], "HEAD"));        export type Insensitive = keyof typeof mapping  type ForwardMapping<I extends Insensitive> = typeof mapping[I];  export type Sensitive = ForwardMapping<Insensitive>;       type ReverseMapping<S extends Sensitive> =     {[K in Insensitive]: ForwardMapping<K> extends S ? K : never}[Insensitive];  export function toSensitive<K extends Insensitive>(    k: K ): ForwardMapping<K> {    return mapping[k];  }  export function matches<K extends Insensitive, L extends Insensitive>(    k: K, l: L ): k is K & ReverseMapping<ForwardMapping<L>> {    return toSensitive(k) === toSensitive(l);  }}

What ends up getting exported is the following types:

type XhrTypes.Sensitive = "GET" | "POST" | "PUT" | "DELETE" |   "OPTIONS" | "CONNECT" | "HEAD"type XhrTypes.Insensitive = "get" | "Get" | "GET" |   "post" | "Post" | "POST" | "put" | "Put" | "PUT" |   "delete" | "Delete" | "DELETE" | "options" | "Options" |  "OPTIONS" | "connect" | "Connect" | "CONNECT" | "head" |   "Head" | "HEAD"

and the functions

 function XhrTypes.toSensitive(k: XhrTypes.Insensitive): XhrTypes.Sensitive; function XhrTypes.matches(k: XhrTypes.Insensitive, l: XhrTypes.Insensitive): boolean;

I'm not sure what you (@Knu) need this for or how you plan to use it, but I'm imagining that you want to convert between sensitive/insensitive methods, or check to see if two case-insensitive methods are a match. Obviously you can do those at runtime by just converting to uppercase or doing a case-insensitive compare, but at compile time the above types may be useful.

Here's an example of using it:

interface HttpStuff {  url: string,  method: XhrTypes.Insensitive,  body?: any}const httpStuff: HttpStuff = {  url: "https://google.com",  method: "get"}interface StrictHttpStuff {  url: string,  method: XhrTypes.Sensitive,  body?: any}declare function needStrictHttpStuff(httpStuff: StrictHttpStuff): Promise<{}>;needStrictHttpStuff(httpStuff); // error, bad methodneedStrictHttpStuff({   url: httpStuff.url,    method: XhrTypes.toSensitive(httpStuff.method)   }); // okay

In the above, there's a function that expects uppercase values, but you can safely pass it a case insensitive value if you use XhrTypes.toSensitive() first, and the compiler verifies that "get" is an acceptable variant of "GET" in this case.

Okay, hope that helps. Good luck.