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

What is the most effective way to move specific data from one page to another in Angular/Typescript?

Why did the homepage load faster than the app.component.ts file?

Using WebdriverIO with Angular to create end-to-end tests in TypeScript that involve importing classes leads to an error stating "Cannot use import statement outside a module."

"Angular encountered an error while attempting to access the property 'data' from an undefined

Tips for establishing communication between a server-side and client-side component in Next.js

Can we handle optional properties that are contingent on a boolean in the type?

The content security policy is preventing a connection to the signalr hub

Turn TypeScript - Modify type properties to reflect types of their descendants

Angular8: Adjusting Activity Status After Leaving Page

Convert JSON data to an array using Observable

Is there a source where I can locate type definitions for Promise objects?

Having trouble importing a TypeScript module from the global node_modules directory

Challenges Encountered when Making Multiple API Requests

The Order ID field in the Serenity-Platform's Order Details tab is not registering orders

Can you explain the correct method for assigning types when destructuring the `callbackFn.currentValue` in conjunction with the `.reduce()` method? Thank you

I am facing an issue with the Angular2 Modal Form where it only displays the data but does

Is it possible to apply a formatting filter or pipe dynamically within an *ngFor loop in Angular (versions 2 and 4

What could be triggering the "slice is not defined" error in this TypeScript and Vue 3 application?

Optimizing Angular for search engines: step-by-step guide

Creating an array with varying types for the first element and remaining elements