Better resolution for correlations in template literal types

[webholics]

🔎 Search Terms

"template literal types", "correlation"

🕗 Version & Regression Information

This is the behavior in every version I tried, and I reviewed the FAQ for entries about "template literal types"

⏯ Playground Link

https://www.typescriptlang.org/play?#code/KYOwrgtgBAKgngB2FA3gKCrRwCCUC8UARAC7Y5EA0GWSAQgcWfUWgL5prPIDSwcAWQCGCRukwBteEgB003AF0AXMSFEoAH2IAjIgG4aU7HOx1lxAMbqtRACb72BtBYD2IAM4koAc2Ak+cIwAPDBQwAAeJKC27rTIhPIAfAAU3CowlFAA1vzuKgHCCFIKAJQEiVAABgAkKNxsMrU5cO5slVBCsa4eJE7cUAAKLu7uAJbaADbAAbGEAEp+YABOIPJB3C4AZj5+ASHYiYkGQA

💻 Code

enum Type {
  TypeA = "typeA",
  TypeB = "typeB"
}

type KeyMap = {
  [Type.TypeA]: "a" | "b";
  [Type.TypeB]: "c" | "d";
};

const getKey = <T extends Type = Type>(type: T, keys: KeyMap[T]) => `${type}.${keys}` as const;

type PossibleKeys = ReturnType<typeof getKey<Type>>;

🙁 Actual behavior

type PossibleKeys = "typeA.a" | "typeA.b" | "typeA.c" | "typeA.d" | "typeB.a" | "typeB.b" | "typeB.c" | "typeB.d"

🙂 Expected behavior

type PossibleKeys = "typeA.a" | "typeA.b" | "typeB.c" | "typeB.d"

Additional information about the issue

I know that the docs about Template Literal Types state that "For each interpolated position in the template literal, the unions are cross multiplied". But I am wondering whether we could to better in such cases or if there is an alternative way to implement this.

[snarbies]

The union type you're getting is correct. The way the function is typed, the following is a valid call, which would return "typeA.c":

getKey<Type>(Type.TypeA, "c");

Technically, all of "typeA.a" | "typeA.b" | "typeA.c" | "typeA.d" | "typeB.a" | "typeB.b" | "typeB.c" | "typeB.d" are possible return results.

[MartinJohns]

Same deal as #57372.

[webholics]

I understand that getKey<Type>(Type.TypeA, "c"); is a valid call.
So
a) it seems to be unrelated to template literal types but more a general issue of specifying oneof generics.
b) there seems to be now solution currently to type this as intended

[rotu]

One workaround (probably not the best) is to use mapped types:

const getKey = <T extends Type = Type>(type: T, keys: KeyMap[T]) => `${type}.${keys}` as keyof {[K in Type as `${K}.${KeyMap[K]}`]:null};

Another is to use a seemingly useless extends to force type expansion to distribute over T.

const getKey = (<T extends Type = Type,>(type: T, keys: KeyMap[T]) => `${type}.${keys}` as (T extends any ? `${T}.${KeyMap[T]}`: never))

[webholics]

Thanks @rotu ! At least this does the job. Your second example is wild.

[typescript-bot]

This issue has been marked as "Duplicate" and has seen no recent activity. It has been automatically closed for house-keeping purposes.