Determine rest parameters based on the initial argument

Question

Determine rest parameters based on the initial argument

Struggling to generate a solution that infers the arguments for an ErrorMessage based on the provided code input.

./errorCodes.ts

export enum ErrorCodes {
  ErrorCode1,
  ErrorCode2,
  ErrorCode3
}

./errorMessages.ts

export const ErrorMessages = {
  [ErrorCodes.ErrorCode1]: (a1: string, a2: string) => `${a1} ${a2} message1...`,
  [ErrorCodes.ErrorCode2]: (a1: boolean) => `${a1} message2...`,
  [ErrorCodes.ErrorCode3]: `message3...`
}

./formatMessage.ts

import {ErrorCodes} from "./errorCodes"
import {ErrorMessages} from './errorMessages'


export const formatMessage = (
  code: ErrorCodes,
  ...args: Parameters<typeof ErrorMessages[typeof ErrorCodes[typeof code]]>
) => {
  const message = ErrorMessages[code];
  const errorCode = `[${ErrorCodes[code]}]`;

  switch (typeof message) {
    case "string": {
      return [errorCode, message].join(" ");
    }
    case "function": {
      return [errorCode, message(...args)].join(" ");
    }
  }

Attempting to define the arguments dynamically:

...args: Parameters<typeof ErrorMessages[typeof ErrorCodes[typeof code]]>

Encountering some challenges:

Lack of autocomplete functionality when calling the function.
Adding string returns in ErrorMessages caused type errors.

typescript types

Answer 1

Answer №1

Let me provide a definition for the function:

export const formatMessage = <E extends ErrorCodes>(
  code: E,
  ...args: typeof ErrorMessages[E] extends infer Fn extends (...args: any) => any 
    ? Parameters<Fn> 
    : [typeof ErrorMessages[E]]
) => {
  const message = ErrorMessages[code];
  const errorCode = `[${ErrorCodes[code]}]`;

  switch (typeof message) {
    case "string": {
      return [errorCode, message].join(" ");
    }
    case "function": {
      return [errorCode, (message as (...args: any) => any)(...args)].join(" ");
    }
  }
}

Now, let's discuss the modifications.

The function needs to be generic. Using something like
```
typeof ErrorMessages[typeof ErrorCodes[typeof code]]
```
may not function as intended. typeof code does not refer to the type of code used when calling the function. It only points to its static type, which is ErrorCodes. This statement just creates a union of all cases.

Instead, we should assign the generic type E to code. The type of E is decided by the caller and can be used in the second parameter type.
The second parameter must employ a conditional type to verify if typeof ErrorMessages[E] is a function type before passing it to Parameters. As you noted, the utility type cannot accept a string because it is not a function.
The error message
```
A spread argument must either have a tuple type or be passed to a rest parameter
```
cannot be completely resolved. The compiler does not entirely comprehend the implications of the type of ...args and how it relates to message. Therefore, we need to assert that message is a function that can be called with any arguments.
```
return [errorCode, (message as (...args: any) => any)(...args)].join(" "); 
```

With these adjustments, the function can now be invoked like this:

formatMessage(ErrorCodes.ErrorCode1, "a", "b")
formatMessage(ErrorCodes.ErrorCode2, true)
formatMessage(ErrorCodes.ErrorCode3, "a")

Playground

Answer 2

Let me provide a definition for the function:

export const formatMessage = <E extends ErrorCodes>(
  code: E,
  ...args: typeof ErrorMessages[E] extends infer Fn extends (...args: any) => any 
    ? Parameters<Fn> 
    : [typeof ErrorMessages[E]]
) => {
  const message = ErrorMessages[code];
  const errorCode = `[${ErrorCodes[code]}]`;

  switch (typeof message) {
    case "string": {
      return [errorCode, message].join(" ");
    }
    case "function": {
      return [errorCode, (message as (...args: any) => any)(...args)].join(" ");
    }
  }
}

Now, let's discuss the modifications.

The function needs to be generic. Using something like
```
typeof ErrorMessages[typeof ErrorCodes[typeof code]]
```
may not function as intended. typeof code does not refer to the type of code used when calling the function. It only points to its static type, which is ErrorCodes. This statement just creates a union of all cases.

Instead, we should assign the generic type E to code. The type of E is decided by the caller and can be used in the second parameter type.
The second parameter must employ a conditional type to verify if typeof ErrorMessages[E] is a function type before passing it to Parameters. As you noted, the utility type cannot accept a string because it is not a function.
The error message
```
A spread argument must either have a tuple type or be passed to a rest parameter
```
cannot be completely resolved. The compiler does not entirely comprehend the implications of the type of ...args and how it relates to message. Therefore, we need to assert that message is a function that can be called with any arguments.
```
return [errorCode, (message as (...args: any) => any)(...args)].join(" "); 
```

With these adjustments, the function can now be invoked like this:

formatMessage(ErrorCodes.ErrorCode1, "a", "b")
formatMessage(ErrorCodes.ErrorCode2, true)
formatMessage(ErrorCodes.ErrorCode3, "a")

Playground

Determine rest parameters based on the initial argument

Answer №1

Similar questions

Transmit data via XMLHttpRequest in smaller portions or through a ReadableStream to minimize memory consumption when handling large datasets

Having trouble obtaining search parameters in page.tsx with Next.js 13

the Sprite fails to appear on the screen

Sorting elements in an array based on an 'in' condition in TypeScript

How to pass parameters between pages in Ionic 2 using navParams when the return nav button is clicked

What is the best way to integrate Tawk.to into a React application while using typescript?

Angular production application is experiencing issues due to a missing NPM package import

Eliminating an element from an object containing nested arrays

Trouble with V-if not updating after property is modified within an async TypeScript function

How to send parameters with the fetch API

Having trouble getting anime.js to function properly in an Ionic 3 project?

Automate the process of triggering the "Organize Imports" command on a VSCode / Typescript project through code

Guide on Implementing Link href in Next.js v12

Working with intricately structured objects using TypeScript

Can anyone assist me with creating a custom sorting pipe in Angular 2?

Accessing properties in Angular/TypeScript: extracting values from a partially extended interface

Tips for resolving the issue when Chrome is able to load the page but Postman cannot find it

Error Message: Angular NullInjectorException - The provider for "[Object]" is not found

Error encountered: Uncaught SyntaxError - An unexpected token '<' was found while matching all routes within the Next.js middleware

organizing strings in alphabetical order using TypeScript