TypeScript mandates the inclusion of either one parameter or the other, without the possibility of having neither

Question

TypeScript mandates the inclusion of either one parameter or the other, without the possibility of having neither

Consider the following type:

export interface Opts {
  paths?: string | Array<string>,
  path?: string | Array<string>
}

The requirement is that the user must provide either 'paths' or 'path', but it is not mandatory to pass both. Currently, the issue is that this code compiles without errors:

export const foo = (o: Opts) => {};
foo({});

Is there a way in TypeScript to allow for two or more optional parameters where at least one is required?

typescript

Answer 1

Answer №1

If needed, you can utilize the following syntax:

export type Choices = { choice: string | Array<string> } | { options: string | Array<string> }

For better clarity, consider rephrasing as follows:

type StringOrArr = string | Array<string>;

type ChoiceOpts  = { choice : StringOrArr };
type OptionsOpts = { options: StringOrArr };

export type Choices = ChoiceOpts | OptionsOpts;

Answer 2

If needed, you can utilize the following syntax:

export type Choices = { choice: string | Array<string> } | { options: string | Array<string> }

For better clarity, consider rephrasing as follows:

type StringOrArr = string | Array<string>;

type ChoiceOpts  = { choice : StringOrArr };
type OptionsOpts = { options: StringOrArr };

export type Choices = ChoiceOpts | OptionsOpts;

Answer 3

Answer №2

If you have an existing interface defined and want to prevent duplicate declarations, one approach is to create a conditional type that takes a type and returns a union with each type containing a single field (along with a record of never values for any additional fields to disallow specifying extra fields).

export interface Options {
    paths?: string | Array<string>,
    path?: string | Array<string>
}

type SingleField<T, Key extends keyof T = keyof T> =
    Key extends keyof T ? { [Prop in Key]-?:T[Key] } & Partial<Record<Exclude<keyof T, Key>, never>>: never
export const handleOptions = (o: SingleField<Options>) => {};
handleOptions({ path : '' });
handleOptions({ paths: '' });
handleOptions({ path : '', paths:'' }); // error
handleOptions({}) // error

Additional Information:

A closer look at the type manipulation technique employed here. We utilize the distributive property of conditional types to essentially iterate over all keys of the T type. The distributive property requires an extra type parameter to function, so we introduce Key for this purpose with a default value of all keys since we aim to extract all keys from type T.

Our goal is to derive individual mapped types for each key of the original type, resulting in a union of these mapped types, each encapsulating just one key. This process removes optionality from the property (indicated by -?, detailed here) while maintaining the same data type as the corresponding property in T (T[Key]).

The final aspect worth elaborating on is

Partial<Record<Exclude<keyof T, Key>, never>>

. Due to how object literals undergo excess property checks, it's possible to assign any field of the union to an object key within an object literal. For instance, a union like

{ path: string | Array<string> } | { paths: string | Array<string> }

permits employing the object literal

{ path: "", paths: ""}</code, which isn't ideal. To remedy this issue, we mandate that if other properties of <code>T

(beyond Key, denoted by Exclude<keyof T, Key>) are included in the object literal of any union member, they must be of type never (hence using

Record<Exclude<keyof T, Key>, never>>

). By partially modifying the preceding record, explicit specification of never for every member is avoided.

Answer 4

If you have an existing interface defined and want to prevent duplicate declarations, one approach is to create a conditional type that takes a type and returns a union with each type containing a single field (along with a record of never values for any additional fields to disallow specifying extra fields).

export interface Options {
    paths?: string | Array<string>,
    path?: string | Array<string>
}

type SingleField<T, Key extends keyof T = keyof T> =
    Key extends keyof T ? { [Prop in Key]-?:T[Key] } & Partial<Record<Exclude<keyof T, Key>, never>>: never
export const handleOptions = (o: SingleField<Options>) => {};
handleOptions({ path : '' });
handleOptions({ paths: '' });
handleOptions({ path : '', paths:'' }); // error
handleOptions({}) // error

Additional Information:

A closer look at the type manipulation technique employed here. We utilize the distributive property of conditional types to essentially iterate over all keys of the T type. The distributive property requires an extra type parameter to function, so we introduce Key for this purpose with a default value of all keys since we aim to extract all keys from type T.

Our goal is to derive individual mapped types for each key of the original type, resulting in a union of these mapped types, each encapsulating just one key. This process removes optionality from the property (indicated by -?, detailed here) while maintaining the same data type as the corresponding property in T (T[Key]).

The final aspect worth elaborating on is

Partial<Record<Exclude<keyof T, Key>, never>>

. Due to how object literals undergo excess property checks, it's possible to assign any field of the union to an object key within an object literal. For instance, a union like

{ path: string | Array<string> } | { paths: string | Array<string> }

permits employing the object literal

{ path: "", paths: ""}</code, which isn't ideal. To remedy this issue, we mandate that if other properties of <code>T

(beyond Key, denoted by Exclude<keyof T, Key>) are included in the object literal of any union member, they must be of type never (hence using

Record<Exclude<keyof T, Key>, never>>

). By partially modifying the preceding record, explicit specification of never for every member is avoided.

Answer 5

Answer №3

This is a functional example.

It allows for the use of a generic type T, specifically with a value of string.

The generic type OneOrMore can be either a single instance of T or an array containing multiple instances of T.

Your input object type Opts is structured to have either a property path containing OneOrMore<T>, or a property paths also containing OneOrMore<T>. There is no other acceptable option provided in the definition.

type OneOrMore<T> = T | T[];

export type Opts<T> = { path: OneOrMore<T> } | { paths: OneOrMore<T> } | never;

export const exampleFunction = (o: Opts<string>) => {};

exampleFunction({});

An issue arises with the usage of {} as an argument.

Answer 6

This is a functional example.

It allows for the use of a generic type T, specifically with a value of string.

The generic type OneOrMore can be either a single instance of T or an array containing multiple instances of T.

Your input object type Opts is structured to have either a property path containing OneOrMore<T>, or a property paths also containing OneOrMore<T>. There is no other acceptable option provided in the definition.

type OneOrMore<T> = T | T[];

export type Opts<T> = { path: OneOrMore<T> } | { paths: OneOrMore<T> } | never;

export const exampleFunction = (o: Opts<string>) => {};

exampleFunction({});

An issue arises with the usage of {} as an argument.

Answer 7

Answer №4

export type Opts={paths: string | Array<string>,  path?: undefined}  |
                 {paths?: undefined,  path: string | Array<string>}

In my opinion, this code is quite clear and easy to comprehend.

Answer 8

export type Opts={paths: string | Array<string>,  path?: undefined}  |
                 {paths?: undefined,  path: string | Array<string>}

In my opinion, this code is quite clear and easy to comprehend.

Answer 9

Answer №5

Searching for a unique union type that suits your needs?

A proposal was presented in the past, but unfortunately, it was rejected. You can read more here.

The suggested solutions didn't resonate with me as I prefer straightforward types over complex ones.

Have you considered using function overloading? It worked for me in a similar scenario.

interface Option1 {
  paths: string | string[];
}

interface Option2 {
  path: string | string[];
}

function foo(o: Option1): void;
function foo(o: Option2): void;
function foo(o: any): any {}

foo({ path: './' });
foo({ paths: '../' });
// The following two lines result in an error: No overload matches this call.
foo({ paths: './', path: '../' });
foo({})

If you prefer using arrow functions, you can adjust the code like this:

interface Option1 {
  paths: string | string[];
}

interface Option2 {
  path: string | string[];
}

interface fooOverload {
  (o: Option1): void;
  (o: Option2): void;
}

const foo: fooOverload = (o: any) => {};

foo({ path: '2' });
foo({ paths: '2' });
// The following two lines will show an error: No overload matches this call.
foo({ paths: '', path: ''});
foo({});

I hope this solution works for you!

Answer 10

Searching for a unique union type that suits your needs?

A proposal was presented in the past, but unfortunately, it was rejected. You can read more here.

The suggested solutions didn't resonate with me as I prefer straightforward types over complex ones.

Have you considered using function overloading? It worked for me in a similar scenario.

interface Option1 {
  paths: string | string[];
}

interface Option2 {
  path: string | string[];
}

function foo(o: Option1): void;
function foo(o: Option2): void;
function foo(o: any): any {}

foo({ path: './' });
foo({ paths: '../' });
// The following two lines result in an error: No overload matches this call.
foo({ paths: './', path: '../' });
foo({})

If you prefer using arrow functions, you can adjust the code like this:

interface Option1 {
  paths: string | string[];
}

interface Option2 {
  path: string | string[];
}

interface fooOverload {
  (o: Option1): void;
  (o: Option2): void;
}

const foo: fooOverload = (o: any) => {};

foo({ path: '2' });
foo({ paths: '2' });
// The following two lines will show an error: No overload matches this call.
foo({ paths: '', path: ''});
foo({});

I hope this solution works for you!

TypeScript mandates the inclusion of either one parameter or the other, without the possibility of having neither

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Similar questions

Does nestjs support typescript version 3.x?

In React, the Textarea component that displays the character count only updates its value after a page reload

I am encountering issues with running my tests using react-testing-library alongside TypeScript

"Frustrating issue with Firebase-admin dependency farmhash-modern resulting in webassembly error

Utilizing the WebSocket readyState to showcase the connection status on the application header

After executing a query to a PostgreSQL database, I encountered an error preventing me from using res.send(). The error message stated: "Cannot set headers after they are sent to the client."

Adjust the specific data type to match its relevant category

How Angular can fetch data from a JSON file stored in an S3

How can we verify if a React component successfully renders another custom component that we've created?

Running an HTTP request conditionally within combineLatest

Parsing error encountered while trying to handle an unexpected token at line 214, character 33. It appears that an appropriate loader is missing to process this particular file type

Issues with accessing view variables within a directive query are persisting

The error message "localStorage is undefined in Angular Universal" indicates that the local

Arranging Pipe Methods in RxJS/Observable for Optimal Functionality

NextJS VSCode Typescript results in breakpoints becoming unbound

The dropdown cannot be disabled because it is being passed as an input parameter

Adding additional properties to Material UI shadows in Typescript is a simple process that can enhance the visual

The cookie value is blank once after moving to the second page

The error message "Property <property> is not recognized on the type 'jQueryStatic<HTMLElement>'" is indicating an issue with accessing a specific property within the TypeScript codebase that utilizes Angular CLI, NPM,

What is the reason for VS Code not displaying doc comments from type properties when suggesting descriptions and hover info for TypeScript objects?