1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
=== tests/cases/compiler/reducibleIndexedAccessTypes.ts ===
// Repro from 53030
enum Type { A, B, C }
>Type : Type
>A : Type.A
>B : Type.B
>C : Type.C
interface PayloadStructure {
dataType: Type;
>dataType : Type
data: unknown;
>data : unknown
}
interface PayloadA extends PayloadStructure {
dataType: Type.A;
>dataType : Type.A
>Type : any
data: string;
>data : string
}
interface PayloadB extends PayloadStructure {
dataType: Type.B;
>dataType : Type.B
>Type : any
data: number;
>data : number
}
interface PayloadC extends PayloadStructure {
dataType: Type.C;
>dataType : Type.C
>Type : any
data: {
>data : { x: number; y: number; }
x: number;
>x : number
y: number;
>y : number
};
}
type Payload = PayloadA | PayloadB | PayloadC
>Payload : PayloadA | PayloadB | PayloadC
type MappedPayload2 = {
>MappedPayload2 : { 0?: ((data: string) => void) | undefined; 1?: ((data: number) => void) | undefined; 2?: ((data: { x: number; y: number; }) => void) | undefined; }
[K in Type]?: (data: (Payload & { dataType: K })["data"]) => void
>data : (Payload & { dataType: K; })["data"]
>dataType : K
}
const payloads2: MappedPayload2 = {
>payloads2 : MappedPayload2
>{ [Type.A]: data => { console.log(data) }} : { 0: (data: string) => void; }
[Type.A]: data => { console.log(data) }
>[Type.A] : (data: string) => void
>Type.A : Type.A
>Type : typeof Type
>A : Type.A
>data => { console.log(data) } : (data: string) => void
>data : string
>console.log(data) : void
>console.log : (...data: any[]) => void
>console : Console
>log : (...data: any[]) => void
>data : string
}
// Additional repro from 53030
type GetPayload<P extends Payload, K extends keyof P> = P extends { dataType: K } ? P["data"] : never;
>GetPayload : GetPayload<P, K>
>dataType : K
// Repro from #51161
type AnyOneof = { oneofKind: string; [k: string]: unknown } | { oneofKind: undefined };
>AnyOneof : { [k: string]: unknown; oneofKind: string; } | { oneofKind: undefined; }
>oneofKind : string
>k : string
>oneofKind : undefined
type AnyOneofKind<T extends AnyOneof> = T extends { oneofKind: keyof T }
>AnyOneofKind : AnyOneofKind<T>
>oneofKind : keyof T
? T['oneofKind']
: never;
|
