Distributive object type infers union rather than specific value | TypeScript Community | Page 1

sinful wharfBOT Feb 9, 2023, 6:32 AM

#

Daniell#4062

Playground Link

Preview:```ts
enum ApplicationCommandType {
ChatInput,
Message,
User,
}

type A = {
type?: ApplicationCommandType.ChatInput
}

type B = {
type: ApplicationCommandType.Message
}

type C = {
type: ApplicationCommandType.User
}

type SlashCommand = A

type ContextMenuCommand = B | C
...```

compact egret Feb 9, 2023, 6:32 AM

#

How can I make this infer a specific type rather than a union?

sudden nimbus Feb 9, 2023, 6:36 AM

#

typescript can't infer the types for some reason

sinful wharfBOT Feb 9, 2023, 6:36 AM

#

n_n#2622

Playground Link

Preview:```ts
...
export const createCommand = <
T extends Extract<
SlashCommand | ContextMenuCommand,
{type?: A}

,
A extends ApplicationCommandType
(
command: Command<T> & {type: A}
) => command
...```

sudden nimbus Feb 9, 2023, 6:36 AM

#

this works though

#

although it's a bit ugly

#

the idea is you have a separate generic parameter to force inference to work

sinful wharfBOT Feb 9, 2023, 6:42 AM

#

Daniell#4062

Playground Link

Preview:```ts
enum ApplicationCommandType {
ChatInput,
Message,
User,
}

type A = {
type?: ApplicationCommandType.ChatInput
description: string
}

type B = {
type: ApplicationCommandType.Message
value: string
}

type C = {
type: ApplicationCommandType.User
...```

compact egret Feb 9, 2023, 6:42 AM

#

I actually solved it by mapping over the enum instead, but there is just 1 more thing I'm trying to achieve which is accessing the rest of the object in Command, is that possible?

#

So basically I want to a conditional type on any value in ApplicationCommandData, I tried but when I make that generic it infers a union for the interaction again :/

#

My attempt was export const createCommand = <T extends ApplicationCommandData>(command: Command<T["type"]>

sudden nimbus Feb 9, 2023, 6:52 AM

#

compact egret I actually solved it by mapping over the enum instead, but there is just 1 more ...

the rest?

compact egret Feb 9, 2023, 6:52 AM

#

sudden nimbus the rest?

Yea I'd like to access the description where the arrow is pointing

#

So that I can do [interaction: ChatInputCommandInteraction, options: Something<TheApplicationCommandDataGeneric["description"]]> for example

sudden nimbus Feb 9, 2023, 6:54 AM

#

uhm

#

that kinda sorta doesn't work

#

because Command depends on Interaction

#

which would also depend on Command with the feature you want

#

but also

#

why not manually make a union

compact egret Feb 9, 2023, 6:56 AM

#

What would that union look like? I've been trying the whole day yesterday if you remember 😅 I just want to infer the parameters of execute correctly while inferring the options array I had in here yesterday

#

Which I changed to description for sake of ease

sinful wharfBOT Feb 9, 2023, 7:00 AM

#

n_n#2622

Playground Link

sudden nimbus Feb 9, 2023, 7:00 AM

#

!ts

sinful wharfBOT Feb 9, 2023, 7:00 AM

#

enum ApplicationCommandType {
  ChatInput,
  Message,
  User
}

type A = {
  type?: ApplicationCommandType.ChatInput
  description: string
}

type B = {
  type: ApplicationCommandType.Message
  value: string
}

type C = {
  type: ApplicationCommandType.User
  value: string
}

type ChatInputCommandInteraction = string;
type ContextMenuCommandInteraction = number;

type Command<D extends string> = 
| { type: ApplicationCommandType.ChatInput; description: D; execute(interaction: ChatInputCommandInteraction, options: [D]): Promise<unknown>; }
| { type: ApplicationCommandType.Message | ApplicationCommandType.User; description: D; execute(interaction: ContextMenuCommandInteraction, options: [D]): Promise<unknown>; }

export const createCommand = <C extends Command<D>, D extends string = C["description"]>(
  command: C
) => command;

createCommand({
  type: ApplicationCommandType.ChatInput,
  description: "test",
  async execute(interaction, options) {
//                           ^? - (parameter) options: [string]
  }
})```

sudden nimbus Feb 9, 2023, 7:00 AM

#

this is pretty nasty too tbh

#

but hey

#

if it works it works

#

plus, avoiding conditional types is always a plus

sinful wharfBOT Feb 9, 2023, 7:03 AM

#

n_n#2622

Playground Link

Preview:ts ... export const createCommand = <const C extends Command<string>>( command: C ) => command; ...

sudden nimbus Feb 9, 2023, 7:03 AM

#

alternatively, with ts 5.0 beta

#

wait no

#

broken

#

the type of options is wrong?

#

which is weird bc the type of description is correct

sinful wharfBOT Feb 9, 2023, 7:05 AM

#

n_n#2622

Playground Link

Preview:```ts
...
export const createCommand = <
C extends Command<D>,
D extends string = C["description"]

(
command: C & {description: D}
) => command
...```

sudden nimbus Feb 9, 2023, 7:05 AM

#

kinda ew

#

but it works

sudden nimbus Feb 9, 2023, 7:06 AM

#

sinful wharf

i've seen a bunch of questions that end up needing something like this lately

#

idk if it's just something about ts 4.9, or if everyone just needs something like this all of a sudden

compact egret Feb 9, 2023, 7:06 AM

#

What also makes it hard is that not every union has a description :/ can I create a repo for you with the actual typings? Because I notice I'm just creating the ideal situation atm

sudden nimbus Feb 9, 2023, 7:07 AM

#

sure

compact egret Feb 9, 2023, 7:10 AM

#

sudden nimbus sure

https://github.com/daniellwdb/ts-issue

GitHub

GitHub - daniellwdb/ts-issue

Contribute to daniellwdb/ts-issue development by creating an account on GitHub.

#

So in case of ApplicationCommandType.ChatInput, I'd like execute: async (interaction, options) => {}, Where options is OptionsAsObject<ApplicationCommandData["options"]>

sudden nimbus Feb 9, 2023, 7:12 AM

#

wait

compact egret Feb 9, 2023, 7:12 AM

#

Options only exist in ChatInputApplicationCommandData

sudden nimbus Feb 9, 2023, 7:12 AM

#

playground says ApplicationCommandOptionType isn't a thing

compact egret Feb 9, 2023, 7:12 AM

#

Yea that's why I couldn't make an accurate playground

#

It doesn't resolve the latest typings

sinful wharfBOT Feb 9, 2023, 7:16 AM

#

n_n#2622

Playground Link

sudden nimbus Feb 9, 2023, 7:16 AM

#

(repro, i haven't started looking at it yet)

compact egret Feb 9, 2023, 7:17 AM

#

Ah lol

sudden nimbus Feb 9, 2023, 7:23 AM

#

!:narrow

sinful wharfBOT Feb 9, 2023, 7:23 AM

#

T6#2591

`!t6:narrow`: Playground Link

Preview:ts type _Narrow<T, U> = [U] extends [T] ? U : Extract<T, U> type Narrow<T = unknown> = | _Narrow<T, 0 | number & {}> | _Narrow<T, 0n | bigint & {}> | _Narrow<T, "" | string & {}> | _Narrow<T, boolean> | _Narrow<T, symbol> | _Narrow<T, []> | _Narrow<T, { [_: PropertyKey]: Narrow }> | (T extends object ? { [K in keyof T]: Narrow<T[K]> } : never) | Extract<{} | null | undefined, T> ...

#

n_n#2622

Playground Link

Preview:```ts
...
export const createCommand = <
C extends Command<OptionsAsObject<O>>,
O extends Narrow<Option[]>

(
command: C & {options: O}
) => command
...```

sudden nimbus Feb 9, 2023, 7:24 AM

#

something like this maybe

#

@compact egret ^

compact egret Feb 9, 2023, 7:26 AM

#

sudden nimbus something like this maybe

I had something like this based on your answers from yesterday but if you change type to ApplicationCommandType.Message, it allows excess properties like options and complains about name which is actually required

#

And with ChatInput it errors when options is not present while it should be optional

#

#

In the original repo it does have correct behaviour when you play around with the type and removal of options / description for reference

sudden nimbus Feb 9, 2023, 8:03 AM

#

ok yeah idk

#

honestly the easiest way is just to extract execute out to a separate parameter

#

and put it back in later

#

after all, the hard part is inferring the object type and making the same object more specific

compact egret Feb 9, 2023, 8:04 AM

#

honestly the easiest way is just to extract execute out to a separate parameter
You mean having this method separate and typing it manually?

sudden nimbus Feb 9, 2023, 8:05 AM

#

no

#

createCommand(command, execute)

#

then you can avoid all the complicated types

#

make the generic for Command like C extends Narrow<Command>

#

and execute would be ExecuteTypeFor<C>

compact egret Feb 9, 2023, 8:07 AM

#

Where did the generic for Command go 🤔

compact egret Feb 9, 2023, 8:19 AM

#

sudden nimbus `createCommand(command, execute)`

I don't think we share the same vision atm, finding myself struggling with this api still

sudden nimbus Feb 9, 2023, 9:57 AM

#

oops

sinful wharfBOT Feb 9, 2023, 9:58 AM

#

n_n#2622

Playground Link

Preview:```ts
...
export const createCommand = <
C extends Narrow<Command>

(
command: C,
execute: CommandExecute<C>
) => ({...command, execute})
...```

sudden nimbus Feb 9, 2023, 9:58 AM

#

got distracted

#

@compact egret ^- this is what i'm talking baout

compact egret Feb 9, 2023, 10:01 AM

#

sudden nimbus <@405778045941841923> ^- this is what i'm talking baout

https://tsplay.dev/mL3L4N Seems to infer the wrong type (should be ContextMenuCommandInteraction in case of anyting but ApplicationCommandType.ChatInput)

TS Playground - An online editor for exploring TypeScript and JavaS...

The Playground lets you write TypeScript or JavaScript online in a safe and sharable way.

sudden nimbus Feb 9, 2023, 10:10 AM

#

woops

#

typo

compact egret Feb 9, 2023, 10:10 AM

#

Okay fixed that, https://tsplay.dev/w1E4yw but the object validation doesn't seem to work

TS Playground - An online editor for exploring TypeScript and JavaS...

The Playground lets you write TypeScript or JavaScript online in a safe and sharable way.

#

Now it's ApplicationCommandType.Message, so the description shouldn't be in the object because MessageApplicationCommandData doesn't allow it

#

Same for options

sudden nimbus Feb 9, 2023, 10:15 AM

#

wiat

#

what's MessageApplicationCommandData

compact egret Feb 9, 2023, 10:16 AM

#

export interface BaseApplicationCommandOptionsData {
  name: string;
  nameLocalizations?: LocalizationMap;
  description: string;
  descriptionLocalizations?: LocalizationMap;
  required?: boolean;
  autocomplete?: never;
}

export interface UserApplicationCommandData extends BaseApplicationCommandData {
  type: ApplicationCommandType.User;
}

export interface MessageApplicationCommandData extends BaseApplicationCommandData {
  type: ApplicationCommandType.Message;
}

export interface ChatInputApplicationCommandData extends BaseApplicationCommandData {
  description: string;
  descriptionLocalizations?: LocalizationMap;
  type?: ApplicationCommandType.ChatInput;
  options?: ApplicationCommandOptionData[];
}

export type ApplicationCommandData =
  | UserApplicationCommandData
  | MessageApplicationCommandData
  | ChatInputApplicationCommandData;

#

Oh seems like description is required, but anything but ChatInput shouldn't allow options

#

ApplicationCommandData is essentially the shape for validation for the object

sinful wharfBOT Feb 9, 2023, 10:28 AM

#

n_n#2622

Playground Link

Preview:```ts
...
export const createCommand = <
C extends Narrow<ApplicationCommandData>

(
command: ForceInference<
C,
Pick<
C,
keyof C &
keyof (ApplicationCommandData & {
type: C["type"]
})

,
execute: CommandExecute<C>
) => ({...command, execute})
...```

sudden nimbus Feb 9, 2023, 10:28 AM

#

@compact egret fixed

#

(probably)

#

oh

#

no autocomplete :(

compact egret Feb 9, 2023, 10:31 AM

#

Yup

sudden nimbus Feb 9, 2023, 10:33 AM

#

yeah honestly

#

i'd just recommend using the const generic modifier

sinful wharfBOT Feb 9, 2023, 10:33 AM

#

n_n#2622

Playground Link

Preview:ts ... export const createCommand = <const C extends ApplicationCommandData>( command: C, execute: CommandExecute<C> ) => ({ ...command, execute }); ...

compact egret Feb 9, 2023, 10:35 AM

#

sudden nimbus i'd just recommend using the `const` generic modifier

How come the wrong interaction type is inferred with this?

#

sudden nimbus Feb 9, 2023, 10:39 AM

#

cuz i'm stupid

#

turns out const generic parameters just...

#

... don't work (?!) with constraints

compact egret Feb 9, 2023, 10:41 AM

#

Well def not stupid, you know your way around shortcomings / quirks way better

#

So you're saying that this is where the wall is hit right? No way around inferring this part

sudden nimbus Feb 9, 2023, 10:51 AM

#

ok

#

one last (?!) thing

sinful wharfBOT Feb 9, 2023, 10:51 AM

#

n_n#2622

Playground Link

Preview:```ts
...
export const createCommand = <
C extends ApplicationCommandData &
Narrow<ApplicationCommandData>

(
command: C,
execute: CommandExecute<C>
) => ({...command, execute})
...```

sudden nimbus Feb 9, 2023, 10:51 AM

#

try this

compact egret Feb 9, 2023, 10:53 AM

#

sudden nimbus try this

Inference for the param works, but excess property issue is back 😅

sudden nimbus Feb 9, 2023, 10:59 AM

#

oh well :/

#

the least bad option is probably to make only options a generic parameter

#

i guess

compact egret Feb 9, 2023, 11:02 AM

#

I don't think that would work though? Because then you'd need some default for the cases where it doesn't exist which would break inference too?

sudden nimbus Feb 9, 2023, 11:02 AM

#

oh right

#

yeah, dang

#

i guess you could make both type and options generic

compact egret Feb 9, 2023, 11:03 AM

#

What would that look like 🤔

sudden nimbus Feb 9, 2023, 11:06 AM

#

createCommand = <Type extends ApplicationCommandType, Options extends Narrow<Option[]>>(command: C & { type: Type; options?: Options; }, execute: CommandExecute<Type, Options>)

#

something like this

sinful wharfBOT Feb 9, 2023, 11:11 AM

#

Daniell#4062

Playground Link

Preview:```ts
import {} from "discord-api-types"

import {
ApplicationCommandOptionData,
ApplicationCommandOptionType,
Attachment,
Channel,
Role,
User,
ChatInputCommandInteraction,
ContextMenuCommandInteraction,
ApplicationCommandType,
ApplicationCommandData
...```

compact egret Feb 9, 2023, 11:11 AM

#

sudden nimbus something like this

Can't get the function signature to work with this

sinful wharfBOT Feb 9, 2023, 11:13 AM

#

n_n#2622

Playground Link

Preview:```ts
...
type CommandExecute<
Type,
O extends ApplicationCommandOptionData[]

= Type extends ApplicationCommandType.ChatInput
? (
interaction: ChatInputCommandInteraction,
options: OptionsAsObject<O>
) => void
: (
interaction: ContextMenuCommandInteraction
) => void
...```

sudden nimbus Feb 9, 2023, 11:14 AM

#

yeah you forgot to fully modify the CommandExecute helper type

compact egret Feb 9, 2023, 11:15 AM

#

sudden nimbus yeah you forgot to fully modify the `CommandExecute` helper type

My bad, this is pretty close to perfect, in this case it seems to still allow options

#

(Not ChatInput)

#

It does validate description etc though

sudden nimbus Feb 9, 2023, 11:17 AM

#

ah yeah that's because of the options?: Options

sinful wharfBOT Feb 9, 2023, 11:18 AM

#

n_n#2622

Playground Link

Preview:```ts
...
export const createCommand = <
Type extends ApplicationCommandType,
Options extends Narrow<
ApplicationCommandOptionData[]

(
command: ApplicationCommandData & {
type: Type
} & (Type extends ApplicationCommandType.ChatInput
? {options: Options}
: {}),
execute: CommandExecute<Type, Options>
) => ({...command, execute})
...```

sudden nimbus Feb 9, 2023, 11:18 AM

#

here's a fix

compact egret Feb 9, 2023, 11:23 AM

#

sudden nimbus here's a fix

Thanks a lot for this, I feel less bad now I was stuck the whole day yesterday because the API I was going for turns out to just not be possible.. Can't explain why though. Could you explain the Narrow type and why it's needed? And also dm your paypal if you want

sudden nimbus Feb 9, 2023, 11:27 AM

#

it's needed because normally:

tuples infer as arrays
strings, numbers, booleans infer as strings, numbers, booleans instead of literal types
object are fine tho

#

in this case you need the option name. i think tuples inferring as arrays isn't that big of a deal in this case

compact egret Feb 9, 2023, 11:33 AM

#

sudden nimbus in this case you need the option name. i think tuples inferring as arrays isn't ...

You mean in general right? Because the type seems to be needed

#

So now it's only needed to get the literal types and not because array > tuple issue

#

createCommand = <Type extends ApplicationCommandType, const Options extends ApplicationCommandOptionData[]>( wish this did magic here

sudden nimbus Feb 9, 2023, 11:36 AM

#

yeah 😔

compact egret Feb 9, 2023, 11:36 AM

#

Well Prettier doesn't work with that syntax anyway so now at least I can move on from this and implement the actual functions with formatting 😅 thanks again

#Distributive object type infers union rather than specific value