type-fest
Version:
A collection of essential TypeScript types
79 lines (63 loc) • 2.99 kB
TypeScript
import type {ConditionalKeys, ConditionalKeysOptions, _DefaultConditionalKeysOptions} from './conditional-keys.d.ts';
import type {ApplyDefaultOptions} from './apply-default-options.d.ts';
import type {Extends} from './internal/type.d.ts';
import type {ExtendsStrict} from './extends-strict.d.ts';
import type {IsNever} from './is-never.d.ts';
/**
Pick keys from the shape that matches the given `Condition`.
This is useful when you want to create a new type from a specific subset of an existing type. For example, you might want to pick all the primitive properties from a class and form a new automatically derived type.
@example
```
import type {Primitive, ConditionalPick} from 'type-fest';
class Awesome {
constructor(public name: string, public successes: number, public failures: bigint) {}
run() {
// do something
}
}
type PickPrimitivesFromAwesome = ConditionalPick<Awesome, Primitive>;
//=> {name: string; successes: number; failures: bigint}
```
@example
```
import type {ConditionalPick} from 'type-fest';
type Example = {
a: string;
b: string | number;
c: () => void;
d: {};
};
type StringKeysOnly = ConditionalPick<Example, string>;
//=> {a: string}
```
Set the `strict` option to `false` to pick a key when any member of its value type extends the condition:
@example
```
import type {ConditionalPick} from 'type-fest';
type OptionalDate = ConditionalPick<{date?: Date; name: string}, Date, {strict: false}>;
//=> {date?: Date}
```
@category Object
*/
// The result is `never` only when no member of a union has a matching key. Once some member has one, an object member without any is kept as `{}`, the same as `ConditionalExcept` keeps an object member it empties. A member that is not an object, like `undefined`, is dropped.
export type ConditionalPick<Base, Condition, Options extends ConditionalKeysOptions = {}> =
ApplyDefaultOptions<ConditionalKeysOptions, _DefaultConditionalKeysOptions, Options> extends infer ResolvedOptions extends Required<ConditionalKeysOptions>
? IsNever<Base extends unknown ? ConditionalKeys<Base, Condition, ResolvedOptions> : never> extends true
? never
: Base extends unknown // For distributing `Base`
? _ConditionalPick<Base, Condition, ConditionalKeys<Base, Condition, ResolvedOptions>, ResolvedOptions['strict'] extends false ? false : true>
: never // Should never happen
: never; // Should never happen
type _ConditionalPick<Base, Condition, Keys, Strict extends boolean> =
IsNever<Keys> extends true
? Base extends object ? {} : never
// Preserve Pick's existing property view for primitive and any inputs.
: ExtendsStrict<Base, object> extends true
? {
// ConditionalKeys excludes array methods; test each value because a matching signature can subsume a nonmatching declared key.
[Key in keyof Base as Key extends Keys
? Extends<Base[Key], Condition, Strict> extends true ? Key : never
: never]: Base[Key]
}
: Pick<Base, Keys & keyof Base>;
export {};