Typing for empty object resulting from a fancy generic

[hushed rivet]

balam314#0

Playground Link

Preview:```ts
/** Returns the type for an arg type string. Example: returns number for "time". */
export type TypeOfArgType<T> =
T extends "string" ? string :
T extends "boolean" ? boolean :
T extends "number" ? number :
T extends "time" ? number :
never;

export type U2I<U> = (
...```

You can choose specific lines to embed by selecting them before copying the link.

[ocean olive]

a function expecting an empty object
a function shouldn't expect an object to be explicitly empty, it would instead not expect there to be any properties, which would be {}. Record<string, never> isn't very useful in any capacity

[wooden gull]

Yep, i need it to be something other than Record<string, never> because thats wrong

I tried using object

but then I get a weird error

[ocean olive]

could you provide some context as to what you're trying to achieve here

[ocean olive]

it's kinda hard to get a comprehensive overview from the scattered comments in the playground

[wooden gull]

sorry, the original playground link was a bit unclear, I added more stuff

ok so, at the high level, it's this

this is a bit of the code that allows that to work

[ocean olive]

and what's the specific thing you're trying to get work here?

[wooden gull]

I have functions that accepts the data passed to a handler function

which varies based on the parameters for that command

some of these functions require args of a specific name

this worked fine

Req.moderate() returns a function that accepts the arguments passed through the handler, and maybe throws an error

this one depends on the arguments object, but there are others that don't care about the arguments object and will work if the arguments object is empty

(null! as CommandHandlerData<"map:string">).args;
//                                           ^?
(null! as CommandHandlerData<never>).args;
//                                   ^?
((y:CommandHandlerData<never>) => {})(null! as CommandHandlerData<"map:string">);
//Type '{ map: string; }' is not assignable to type 'Record<string, never>'
//I should be able to pass an object with data to a function expecting an empty object
((y:Record<string, never>) => {})({map: "hi"}); //nope
((y:object) => {})({map: "hi"}); //this works

what's happening there is

I have the arguments object for a command with arbitrary arguments

and want to pass that to a function that accepts any kind of argument object

[tepid thicket]

The easiest way to fix it is to get rid of U2I:

[hushed rivet]

nonspicyburrito#0

Playground Link

Preview:ts /** Returns the type for an arg type string. Example: returns `number` for "time". */ export type TypeOfArgType<T> = T extends 'string' ? string : T extends 'boolean' ? boolean : T extends 'number' ? number : T extends 'time' ...

You can choose specific lines to embed by selecting them before copying the link.

[ocean olive]

so CommandHandlerData<"map:string"> needs to be a subtype of CommandHandlerData<never>?

[tepid thicket]

But I would personally write it in a very different way.

[wooden gull]

I'm not sure... the first one needs to have { args: { map: string } } and the second one needs to return { /* no info about what properties it might have */ }

[wooden gull]

Oh nice, this might work

[ocean olive]

well, a {}, which would have that relationship

[tepid thicket]

Here's how I would write it:

[hushed rivet]

nonspicyburrito#0

Playground Link

Preview:```ts
type TypeMap = {
string: string
boolean: boolean
number: number
time: number
}

type ToType<T> = TypeMap[T & keyof TypeMap]

type ExtractName<T> = T extends ${infer N}:${string}
? N
: never

type ExtractType<T> = T extends `${string}
...```

You can choose specific lines to embed by selecting them before copying the link.

[tepid thicket]

With this solution, you don't need to check for never explicitly, it just works.

[wooden gull]

but that didn't work, I get this error

Argument of type 'CommandHandlerData<"map:string">' is not assignable to parameter of type 'CommandHandlerData<never>'.
  Type 'string' is not assignable to type 'never'.

which doesn't make sense, why is it trying to compare "string" with "never"?

[wooden gull]

this is nice
what is [K in ... as ...], havent seen that before

[tepid thicket]

!hb mapped

[hushed rivet]

Handbook

Mapped Types

[tepid thicket]

It's the "as remapping" section.

[wooden gull]

this fixed my issue, thank you very much