1- import { Diff } from './strings' ;
21import { False , True } from './conditionals' ;
3- import { AnyFunc } from './functions' ;
42
53// -------
64// Helpers
@@ -16,7 +14,7 @@ export type PlainObject = Record<string, any>;
1614 * @returns An object formed by the key, value pairs of T
1715 */
1816export type ObjectType < T > = {
19- [ k in Keys < T > ] : T [ k ] ;
17+ [ k in keyof T ] : T [ k ] ;
2018} ;
2119/**
2220 * Takes two objects and returns their intersection.
@@ -35,7 +33,7 @@ export type CombineObjects<T extends object, U extends object> = ObjectType<T &
3533 * @param K Key to query object for value
3634 * @returns `T[K]` if the key exists, `never` otherwise
3735 */
38- export type GetKey < T , K extends keyof any > = K extends Keys < T > ? T [ K ] : never ;
36+ export type GetKey < T , K extends keyof any > = K extends keyof T ? T [ K ] : never ;
3937
4038// ----
4139// Keys
@@ -56,51 +54,45 @@ export type ObjectKeys = keyof any;
5654 * @param T type from which to get keys
5755 * @returns keys of `T` that extend `string`
5856 */
59- export type StringKeys < T > = Exclude < Keys < T > , number | symbol > ;
60- /**
61- * No different than `keyof`, but can look a bit nicer when nesting many types deep.
62- * @param T type from which to get keys
63- * @returns keys of `T` that extend `string | number | symbol`
64- */
65- export type Keys < T > = keyof T ;
57+ export type StringKeys < T > = Exclude < keyof T , number | symbol > ;
6658/**
6759 * When an object has optional or readonly keys, that information is contained within the key.
6860 * When using optional/readonly keys in another object, they will retain optional/readonly status.
6961 * `PureKeys` will remove the optional/readonly status modifiers from keys.
7062 * @param T type from which to get keys
7163 * @returns keys of `T` without status modifiers (readonly/optional)
7264 */
73- export type PureKeys < T > = Record < Keys < T > , Keys < T > > [ Keys < T > ] ;
65+ export type PureKeys < T > = Record < keyof T , keyof T > [ keyof T ] ;
7466/**
7567 * Gets all of the keys that are shared between two objects.
7668 * @param T first type from which keys will be pulled
7769 * @param U second type from which keys will be pulled
7870 * @returns the keys that both `T` and `U` have in common.
7971 */
80- export type SharedKeys < T , U > = Keys < T > & Keys < U > ;
72+ export type SharedKeys < T , U > = keyof T & keyof U ;
8173/**
8274 * Gets all keys between two objects.
8375 * @param T first type from which keys will be pulled
8476 * @param U second type from which keys will be pulled
8577 * @returns the keys of `T` in addition to the keys of `U`
8678 */
87- export type AllKeys < T , U > = Keys < T > | Keys < U > ;
79+ export type AllKeys < T , U > = keyof T | keyof U ;
8880/**
8981 * Gets all of the keys that are different between two objects.
90- * This is a set difference between `Keys<T> ` and `Keys<U> `.
82+ * This is a set difference between `keyof T ` and `keyof U `.
9183 * Note that calling this with arguments reversed will have different results.
9284 * @param T first type from which keys will be pulled
9385 * @param U second type from which keys will be pulled
9486 * @returns keys of `T` minus the keys of `U`
9587 */
96- export type DiffKeys < T , U > = Diff < Keys < T > , Keys < U > > ;
88+ export type DiffKeys < T , U > = Exclude < keyof T , keyof U > ;
9789/**
9890 * Returns `True` if a key, `K`, is present in a type, `T`, else `False`.
9991 * @param T type to check for existence of key `K`.
10092 * @param K key to query `T` for
10193 * @returns `True` if `K` is a key of `T`. Else `False`.
10294 */
103- export type HasKey < T , K extends keyof any > = K extends Keys < T > ? True : False ;
95+ export type HasKey < T , K extends keyof any > = K extends keyof T ? True : False ;
10496
10597/**
10698 * @param T the union to get the keys of
@@ -109,7 +101,7 @@ export type HasKey<T, K extends keyof any> = K extends Keys<T> ? True : False;
109101export type UnionKeys < T >
110102 // Using a conditional here, so that it distributes over members of the union
111103 // See https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
112- = T extends any ? keyof T : never ;
104+ = T extends unknown ? keyof T : never ;
113105
114106// -------------
115107// Manipulations
@@ -119,15 +111,15 @@ export type UnionKeys<T>
119111 * @param T the object whose property values will be unionized
120112 * @returns a union of the right-side values of `T`
121113 */
122- export type UnionizeProperties < T extends object > = T [ Keys < T > ] ;
114+ export type UnionizeProperties < T extends object > = T [ keyof T ] ;
123115/**
124116 * Gives back an object with listed keys removed.
125117 * This is the opposite of `Pick`.
126118 * @param T the object whose properties will be removed
127119 * @param K the union of keys to remove from `T`
128120 * @returns `T` with the keys `K` removed
129121 */
130- export type Omit < T extends object , K extends Keys < T > > = Pick < T , Diff < Keys < T > , K > > ;
122+ export type Omit < T extends object , K extends keyof T > = Pick < T , Exclude < keyof T , K > > ;
131123/**
132124 * Returns only the shared properties between two objects.
133125 * All shared properties must be the same type.
@@ -161,7 +153,7 @@ export type Merge<T extends object, U extends object> = Overwrite<T, U> & U;
161153 * @returns a record where each key of the record is now the `Key` property of the inner object
162154 */
163155export type TaggedObject < T extends Record < keyof any , object > , Key extends keyof any > = {
164- [ K in Keys < T > ] : T [ K ] & Record < Key , K > ;
156+ [ K in keyof T ] : T [ K ] & Record < Key , K > ;
165157} ;
166158
167159// ---------
@@ -174,9 +166,9 @@ export type TaggedObject<T extends Record<keyof any, object>, Key extends keyof
174166 * @returns `Partial<T>` recursively through all properties of `T`
175167 */
176168export type DeepPartial < T > = Partial < {
177- [ k in Keys < T > ] :
178- T [ k ] extends any [ ] ? Array < DeepPartial < T [ k ] [ number ] > > :
179- T [ k ] extends AnyFunc ? T [ k ] :
169+ [ k in keyof T ] :
170+ T [ k ] extends unknown [ ] ? Array < DeepPartial < T [ k ] [ number ] > > :
171+ T [ k ] extends Function ? T [ k ] :
180172 T [ k ] extends object ? DeepPartial < T [ k ] > :
181173 T [ k ] ;
182174} > ;
@@ -186,15 +178,15 @@ export type DeepPartial<T> = Partial<{
186178 * @returns `T` with all fields marked required
187179 */
188180export type AllRequired < T extends object > = {
189- [ K in Keys < T > ] -?: NonNullable < T [ K ] >
181+ [ K in keyof T ] -?: NonNullable < T [ K ] >
190182} ;
191183/**
192184 * Mark specific keys, `K`, of `T` as required.
193185 * @param T object whose keys will be marked required
194186 * @param K keys of `T` that will be marked required
195187 * @returns `T` with keys, `K`, marked as required
196188 */
197- export type Required < T extends object , K extends Keys < T > > = CombineObjects <
189+ export type Required < T extends object , K extends keyof T > = CombineObjects <
198190 { [ k in K ] -?: NonNullable < T [ k ] > } ,
199191 Omit < T , K >
200192> ;
@@ -204,7 +196,7 @@ export type Required<T extends object, K extends Keys<T>> = CombineObjects<
204196 * @param K keys of `T` that will be marked optional
205197 * @returns `T` with keys, `K`, marked as optional
206198 */
207- export type Optional < T extends object , K extends Keys < T > > = CombineObjects <
199+ export type Optional < T extends object , K extends keyof T > = CombineObjects <
208200 { [ k in K ] ?: T [ k ] | undefined } ,
209201 Omit < T , K >
210202> ;
@@ -214,9 +206,9 @@ export type Optional<T extends object, K extends Keys<T>> = CombineObjects<
214206 * @returns `T` with all keys recursively marked as readonly
215207 */
216208export type DeepReadonly < T > = Readonly < {
217- [ k in Keys < T > ] :
218- T [ k ] extends any [ ] ? ReadonlyArray < DeepReadonly < T [ k ] [ number ] > > :
219- T [ k ] extends AnyFunc ? T [ k ] :
209+ [ k in keyof T ] :
210+ T [ k ] extends unknown [ ] ? ReadonlyArray < DeepReadonly < T [ k ] [ number ] > > :
211+ T [ k ] extends Function ? T [ k ] :
220212 T [ k ] extends object ? DeepReadonly < T [ k ] > :
221213 T [ k ] ;
222214} > ;
@@ -261,6 +253,6 @@ export type StrictUnion<T> = _StrictUnionHelper<T, T>;
261253// to refer to each individual member of the union
262254/** no-doc */
263255export type _StrictUnionHelper < UnionMember , Union > =
264- UnionMember extends any ?
256+ UnionMember extends unknown ?
265257 UnionMember & Partial < Record < Exclude < UnionKeys < Union > , keyof UnionMember > , never > >
266258 : never ;
0 commit comments