Typing function arguments based off array of argument types | TypeScript Community | Page 1

carmine delta May 21, 2024, 1:50 AM

#

I need help completing this type:

interface ReturnTypes {
  string: string;
  number: number;
  boolean: boolean;
}

interface CommandOption {
    type: keyof ReturnTypes;
}

interface Command<Options extends CommandOption[] = CommandOption[]> {
  options?: Options;
  handler: (...args: ?) => void; // Complete the type.
}

const command = {
  options: [
    {
      type: "string",
    },
    {
      type: "number",
    },
    {
      type: "boolean",
    },
  ],
  handler(string, number, boolean) {
    
  },
} satisfies Command;

I know ReturnTypes would be used at some point, but not sure how to do the rest.

carmine delta May 21, 2024, 3:12 AM

#

Dang I thought this would work

type OptionArguments<Options extends CommandOption[]> = Options extends [
  infer First extends CommandOption,
  ...infer Last extends CommandOption[]
]
  ? [ReturnTypes[First["type"]], ...OptionArguments<Last>]
  : never;

pallid oracle May 21, 2024, 4:02 AM

#

I can't really work out what you are trying to do.

carmine delta May 21, 2024, 4:03 AM

#

pallid oracle I can't really work out what you are trying to do.

I would like to type the handler with the types from options.

#

for example: ```ts
handler: (...args: [string, number, boolean]) => void;


but based off the types in "options"

pallid oracle May 21, 2024, 4:05 AM

#

You mean if you set options as [{ type: string }, { type: number }] then the args would be [string, number] ?

carmine delta May 21, 2024, 4:05 AM

#

yep

pallid oracle May 21, 2024, 4:05 AM

#

So we probably just need a little mapped type

carmine delta May 21, 2024, 4:06 AM

#

I just noticed I called them "ReturnTypes" but they are not return types. Should have been "ArgumentTypes" lol

pallid oracle May 21, 2024, 4:10 AM

#

wait a min

#

OK I think that is working, but you did some really weird things, so let's unpick those

#

interface ArgumentTypes {
  string: string;
  number: number;
  boolean: boolean;
}

interface CommandOption {
    type: keyof ArgumentTypes;
}

#

The key ArgumentTypes is a string literal 'string' 'number' 'boolean'

#

I am guess you don't want a string literal, but rather a type?

carmine delta May 21, 2024, 4:14 AM

#

Yeah I want the type to be a string, as its coming from an API

pallid oracle May 21, 2024, 4:14 AM

#

hmm, but the type is written as a string

#

so we need to convert from a type name string to a type

#

handler(a: string, b: number, c: boolean) {

}

And this would be a valid handler?

carmine delta May 21, 2024, 4:16 AM

#

Yea

pallid oracle May 21, 2024, 4:17 AM

#

Somewhere this is a thing to convert a string to a type, but I can't find it

#

Can we use something brute forcy for this?

#

type StringToType<T extends string> = T extends 'number' ? number : T extends 'boolean' ? boolean : never;

like this?

carmine delta May 21, 2024, 4:18 AM

#

Doesnt the interface do the same thing?

pallid oracle May 21, 2024, 4:19 AM

#

hmm does it

#

yeah I suppose so, I get what you're doing now 😄

winged fractalBOT May 21, 2024, 4:21 AM

#

sandiford#0

Playground Link

Preview:```ts
interface ArgumentTypes {
string: string
number: number
boolean: boolean
}

type ArgumentType = keyof ArgumentTypes

interface CommandOption {
type: ArgumentType
}

type ArgsFromOptions<
Options extends readonly CommandOption[]

= {
[K in keyof Options]: ArgumentTypes[Options[K]["type"]]
...```

pallid oracle May 21, 2024, 4:22 AM

#

I think it won't work with satisfies

carmine delta May 21, 2024, 4:24 AM

#

function defineCommand<const T extends Command>(command: T) {
  return command;
}

#

this should force everything to be const

pallid oracle May 21, 2024, 4:24 AM

#

OK

carmine delta May 21, 2024, 4:24 AM

#

oh you did something like that

pallid oracle May 21, 2024, 4:25 AM

#

Well, I was just trying that. Your approach seems best.

#

the readonly's are not necessary, they don't seem to change anything

winged fractalBOT May 21, 2024, 4:25 AM

#

sandiford#0

Playground Link

Preview:```ts
interface ArgumentTypes {
string: string;
number: number;
boolean: boolean;
}

type ArgumentType = keyof ArgumentTypes

interface CommandOption {
type: ArgumentType;
}

type ArgsFromOptions<Options extends CommandOption[]> = {
[K in keyof Options]: ArgumentTypes[Options[K]['type']]
...```

pallid oracle May 21, 2024, 4:28 AM

#

interface Command<Options extends CommandOption[] = CommandOption[]> {

I suspect that the default type here isn't useful. It doesn't match any real defined command, and not sure how else it can be useful.

#

So I'd probably remove that, to remind me that I need to specify an Options type

carmine delta May 21, 2024, 4:30 AM

#

I definitely tried your solution but only with satisfies, so probably thats why it didnt work.

carmine delta May 21, 2024, 5:01 AM

#

wonder why you have to specify const Options extends CommandOptions[] and not const T extends Command

pallid oracle May 21, 2024, 5:10 AM

#

Command is Command<CommandOption[]>

#

When you use a Generic type you need to provide the type argument for it, or else let it use its default

#

Which is part of why I say you should remove the default type for it, as you think you're using it Generically, when actually you are using it as Command<CommandOption[]>, and Command<CommandOption[]> is basically useless

#

// no type errors, but nonsensical
const commandWithSatisfies = {
  options: [
    {
      type: "string",
    },
    {
      type: "number",
    },
    {
      type: "boolean",
    },
  ] as const,
  handler(
    a: ArgumentTypes[ArgumentType],
    b: ArgumentTypes[ArgumentType],
    c: ArgumentTypes[ArgumentType],
    d: ArgumentTypes[ArgumentType]
  ) {
  },
} satisfies Command;

to satisfy that constraint you need to use string | number | boolean for each arg, and you can do weird things like provide more arguements than entries in your options.

#

And T extends Command<CommandOption[]> is not the same as Command<T extends CommandOption[]> of course

#Typing function arguments based off array of argument types