@@ -2,77 +2,77 @@ import {expectType} from 'tsd';
2
2
import type { UnionToEnum } from '../index.d.ts' ;
3
3
4
4
// Union input
5
- expectType < UnionToEnum < 'b' | 'a' | 'd' | 'c' > > ( { b : 'b' , a : 'a' , d : 'd' , c : 'c' } ) ;
6
- expectType < UnionToEnum < 3 | 2 | 4 | 1 > > ( { 1 : 1 , 2 : 2 , 3 : 3 , 4 : 4 } ) ;
5
+ expectType < UnionToEnum < 'b' | 'a' | 'd' | 'c' > > ( { b : 'b' , a : 'a' , d : 'd' , c : 'c' } as const ) ;
6
+ expectType < UnionToEnum < 3 | 2 | 4 | 1 > > ( { 1 : 1 , 2 : 2 , 3 : 3 , 4 : 4 } as const ) ;
7
7
8
8
// Tuple input
9
- expectType < UnionToEnum < [ 'One' , 'Two' ] > > ( { One : 'One' , Two : 'Two' } ) ;
10
- expectType < UnionToEnum < [ 'X' , 'Y' , 'Z' ] , true > > ( { X : 1 , Y : 2 , Z : 3 } ) ;
9
+ expectType < UnionToEnum < [ 'One' , 'Two' ] > > ( { One : 'One' , Two : 'Two' } as const ) ;
10
+ expectType < UnionToEnum < [ 'X' , 'Y' , 'Z' ] , true > > ( { X : 1 , Y : 2 , Z : 3 } as const ) ;
11
11
12
12
// Single element tuple
13
- expectType < UnionToEnum < [ 'Only' ] > > ( { Only : 'Only' } ) ;
14
- expectType < UnionToEnum < 'Only' , true > > ( { Only : 1 } ) ;
13
+ expectType < UnionToEnum < [ 'Only' ] > > ( { Only : 'Only' } as const ) ;
14
+ expectType < UnionToEnum < 'Only' , true > > ( { Only : 1 } as const ) ;
15
15
16
16
// Tuple with numeric keys
17
- expectType < UnionToEnum < [ 1 , 2 , 3 ] > > ( { 1 : 1 , 2 : 2 , 3 : 3 } ) ;
18
- expectType < UnionToEnum < [ 1 , 2 , 3 ] , true , { startIndex : 10 } > > ( { 1 : 10 , 2 : 11 , 3 : 12 } ) ;
17
+ expectType < UnionToEnum < [ 1 , 2 , 3 ] > > ( { 1 : 1 , 2 : 2 , 3 : 3 } as const ) ;
18
+ expectType < UnionToEnum < [ 1 , 2 , 3 ] , true , { startIndex : 10 } > > ( { 1 : 10 , 2 : 11 , 3 : 12 } as const ) ;
19
19
20
20
// Mixed keys
21
- expectType < UnionToEnum < [ 'a' , 1 , 'b' ] > > ( { a : 'a' , 1 : 1 , b : 'b' } ) ;
22
- expectType < UnionToEnum < [ 'a' , 1 , 'b' ] , true , { startIndex : 0 } > > ( { a : 0 , 1 : 1 , b : 2 } ) ;
21
+ expectType < UnionToEnum < [ 'a' , 1 , 'b' ] > > ( { a : 'a' , 1 : 1 , b : 'b' } as const ) ;
22
+ expectType < UnionToEnum < [ 'a' , 1 , 'b' ] , true , { startIndex : 0 } > > ( { a : 0 , 1 : 1 , b : 2 } as const ) ;
23
23
24
24
// Literal const arrays
25
25
const buttons = [ 'Play' , 'Pause' , 'Stop' ] as const ;
26
26
27
- expectType < UnionToEnum < typeof buttons > > ( { Play : 'Play' , Pause : 'Pause' , Stop : 'Stop' } ) ;
28
- expectType < UnionToEnum < typeof buttons , true , { startIndex : 0 } > > ( { Play : 0 , Pause : 1 , Stop : 2 } ) ;
27
+ expectType < UnionToEnum < typeof buttons > > ( { Play : 'Play' , Pause : 'Pause' , Stop : 'Stop' } as const ) ;
28
+ expectType < UnionToEnum < typeof buttons , true , { startIndex : 0 } > > ( { Play : 0 , Pause : 1 , Stop : 2 } as const ) ;
29
29
30
30
// Symbol keys
31
31
declare const sym1 : unique symbol ;
32
32
declare const sym2 : unique symbol ;
33
33
34
- expectType < UnionToEnum < typeof sym1 | typeof sym2 > > ( { [ sym1 ] : sym1 , [ sym2 ] : sym2 } ) ;
35
- expectType < UnionToEnum < [ typeof sym1 , typeof sym2 ] > > ( { [ sym1 ] : sym1 , [ sym2 ] : sym2 } ) ;
34
+ expectType < UnionToEnum < typeof sym1 | typeof sym2 > > ( { [ sym1 ] : sym1 , [ sym2 ] : sym2 } as const ) ;
35
+ expectType < UnionToEnum < [ typeof sym1 , typeof sym2 ] > > ( { [ sym1 ] : sym1 , [ sym2 ] : sym2 } as const ) ;
36
36
37
37
// Unordered union with numeric flag
38
- expectType < UnionToEnum < 'left' | 'right' | 'up' | 'down' , true > > ( { left : 1 , right : 2 , up : 3 , down : 4 } ) ;
38
+ expectType < UnionToEnum < 'left' | 'right' | 'up' | 'down' , true > > ( { left : 1 , right : 2 , up : 3 , down : 4 } as const ) ;
39
39
40
40
// Large union
41
41
type BigUnion = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' ;
42
- expectType < UnionToEnum < BigUnion > > ( { a : 'a' , b : 'b' , c : 'c' , d : 'd' , e : 'e' , f : 'f' , g : 'g' } ) ;
42
+ expectType < UnionToEnum < BigUnion > > ( { a : 'a' , b : 'b' , c : 'c' , d : 'd' , e : 'e' , f : 'f' , g : 'g' } as const ) ;
43
43
44
44
// Non-literal input fallback
45
45
expectType < UnionToEnum < string > > ( { } as Record < string , string > ) ;
46
46
expectType < UnionToEnum < number > > ( { } as Record < number , number > ) ;
47
47
expectType < UnionToEnum < symbol > > ( { } as Record < symbol , symbol > ) ;
48
48
49
- expectType < UnionToEnum < string [ ] > > ( { } ) ;
50
- expectType < UnionToEnum < number [ ] > > ( { } ) ;
51
- expectType < UnionToEnum < symbol [ ] > > ( { } ) ;
49
+ expectType < UnionToEnum < string [ ] > > ( { } as const ) ;
50
+ expectType < UnionToEnum < number [ ] > > ( { } as const ) ;
51
+ expectType < UnionToEnum < symbol [ ] > > ( { } as const ) ;
52
52
53
53
// `never` / `any`
54
- expectType < UnionToEnum < never > > ( { } ) ;
55
- expectType < UnionToEnum < any > > ( { } ) ;
54
+ expectType < UnionToEnum < never > > ( { } as const ) ;
55
+ expectType < UnionToEnum < any > > ( { } as const ) ;
56
56
57
57
// CamelCase
58
58
const level = [ 'DEBUG' , 'INFO' , 'ERROR' , 'WARNING' ] as const ;
59
59
expectType < UnionToEnum < typeof buttons , false , { camelCase : true } > > ( {
60
60
play : 'Play' ,
61
61
pause : 'Pause' ,
62
62
stop : 'Stop' ,
63
- } ) ;
63
+ } as const ) ;
64
64
expectType < UnionToEnum < typeof level , false , { camelCase : true } > > ( {
65
65
debug : 'DEBUG' ,
66
66
info : 'INFO' ,
67
67
error : 'ERROR' ,
68
68
warning : 'WARNING' ,
69
- } ) ;
69
+ } as const ) ;
70
70
expectType < UnionToEnum < typeof level , true , { camelCase : true } > > ( {
71
71
debug : 1 ,
72
72
info : 2 ,
73
73
error : 3 ,
74
74
warning : 4 ,
75
- } ) ;
75
+ } as const ) ;
76
76
77
77
// Dynamic Enum
78
78
const verb = [ 'write' , 'read' , 'delete' ] as const ;
@@ -95,4 +95,4 @@ expectType<typeof Template>({
95
95
deleteFile : 'delete_file' ,
96
96
deleteFolder : 'delete_folder' ,
97
97
deleteLink : 'delete_link' ,
98
- } ) ;
98
+ } as const ) ;
0 commit comments