I would like to create a function that restricts the arguments passed. dpr and w should not be both passed at the same time. Here's my attempt:
interface W { w: number }
interface Dpr { dpr: number }
type Srcset<T> = { url: string } & WidthOrDpr<T>
type WidthOrDpr<T> = T extends W ? W : Dpr;
function formatSrcset<T extends W | Dpr>(options: Srcset<T>) {
}
formatSrcset({ url: '//', dpr: 1 }); // ok
formatSrcset({ url: '//', w: 1 }); // ok
formatSrcset({ url: '//', w: 1, dpr: 1 }); // should fail
I would like to avoid function overloads.
This is not the most concise code, but what if you forced dpr / w to be undefined by defining two interfaces for the different arg options? Something like this:
type Args1 = { dpr: number, w?: undefined };
type Args2 = { dpr?: undefined, w: number };
type Srcset<T> = { url: string } & (Args1 | Args2);
You can use type-fest's RequireAtLeastOne
// code from sindresorhus/type-fest
type RequireAtLeastOne<
ObjectType,
KeysType extends keyof ObjectType = keyof ObjectType,
> = {
// For each `Key` in `KeysType` make a mapped type:
[Key in KeysType]-?: Required<Pick<ObjectType, Key>> & // 1. Make `Key`'s type required
// 2. Make all other keys in `KeysType` optional
Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
}[KeysType] &
// 3. Add the remaining keys not in `KeysType`
Except<ObjectType, KeysType>;
In your case
type Args = RequireAtLeastOne<{
url: string
dpr?: number
w?: number
}, 'dpr' | 'w'>
function fn({ url, dpr, w }: Args) {...}