Inside a generic function with a remapped type as parameter, elements are wrongfully inferred as {}.

[denis-migdal]

🔎 Search Terms

remapped
key mapping
generics

Maybe related:

• Incorrect substitution on index access with generic key type on generic mapped type with key remapping  #47794
• Contextual type of a property type not inferred with key remapping #48855

🕗 Version & Regression Information

• tested on playground v6.0.2

⏯ Playground Link

Playground Link

💻 Code

    type RenameKeys<H extends Record<string, any>> = {
        [K in string&keyof H as `on${Capitalize<K>}`]: () => void
    };

    function foo<T extends Record<string, any>>(handlers: RenameKeys<T>) {

        for(const name in handlers) {
            let handler: () => void = handlers[name]!; // nok
            // inferred as {} instead of () => void;
            // Type 'NonNullable<RenameKeys<T>[Extract<keyof RenameKeys<T>, string>]>' is not assignable to type '() => void'.
           // Type '{}' provides no match for the signature '(): void'.(2322)
        }
   }

🙁 Actual behavior

The type of the elements of the remapped type is {} inside the generic function.

If we return the element, the returned type is correct (cf playground).

🙂 Expected behavior

The type should be either:

• () = void (correct)
• unknown or any: TS is unable to properly infer the type.

Having {} is quite strange/surprising.

Additional information about the issue

There is another issue with [K in string&keyof H] which doesn't manifest when we use [K in keyof H] (cf playground):

type RenameKeys<H extends Record<string, any[]>> = {
     [K in string&keyof H]: (...args: H[K]) => void
};

function foo<T extends Record<string, any>>(handlers: RenameKeys<T>) {

        for(const name in handlers)
            return handlers[name]!;

        throw new Error("ok");
}

const x = foo({onFoo: (e: 42) => {}}); // nok : (...args: unknown) => void

[denis-migdal]

Note this behavior was introduced after 5.3.3, previously the error was :

Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'RenameKeys<T>'.
  No index signature with a parameter of type 'string' was found on type 'RenameKeys<T>'.(7053)

[RyanCavanaugh]

Why are you writing the function signature this way in the first place?

[denis-migdal]

Why are you writing the function signature this way in the first place?

This is a minimal reproductible exemple (see below for the real code).

This is a hook system where the hook have names xxx and the corresponding handler is named onXxx.

The real signature is:

setHandlers<T extends WithHooks>(target: T, handlers: Partial<GetHandlers<NoInfer<T>>>)

Playground Link

type Hook    = (...args: any[]) => any;
export type Hooks   = Record<string, Hook>;

const NO_HANDLER = Symbol();

export class HooksManager<T extends Hooks> {

    protected hooks: Partial<T> = {};

    trigger<K extends keyof T>(name: K, ...args: Parameters<T[K]>): ReturnType<T[K]>|typeof NO_HANDLER {
        const hook = this.hooks[name];
        if( hook === undefined )
            return NO_HANDLER;

        return hook(...args);
    }   

    setHandlers(bindedHandlers: Partial<T>) {
        this.hooks = bindedHandlers;
    }
}

type WithHooks = {hooks: HooksManager<any>};
type GetHooks<T extends WithHooks> = T["hooks"] extends HooksManager<infer H> ? H : never;
type Hooks2Handlers<T extends {}, H extends Hooks> = {
    [K in string&keyof H as `on${Capitalize<K>}`]: (
                                                source : Omit<T, "hooks">,
                                                ...args: Parameters<H[K]>
                                            ) => ReturnType<H[K]>
};

export type GetHandlers<T extends WithHooks> = Hooks2Handlers<T, GetHooks<T>>;

export function isHandlerName(name: string): name is `on${Capitalize<string>}` {
    return name[0] === "o" && name[1] === "n" && name[2] >= "A" && name[2] <= "Z";
}

export function setHandlers<T extends WithHooks>(
                            target: T,
                            handlers: Partial<GetHandlers<NoInfer<T>>>
                        ) {

    const bindedHandlers = {} as Partial<GetHooks<T>>;

    let bindedName   : string;
    let handler      : (t: unknown, ...args: unknown[]) => unknown;
    let bindedHandler: (...args: unknown[]) => unknown;

    for(const name in handlers) {
        if( ! isHandlerName(name) )
            continue;
        
        bindedName    = name[2].toLocaleLowerCase() + name.slice(3);
        handler       = handlers[name]! as any;
        bindedHandler = (...args: any[]) => handler(target, ...args);

        // @ts-ignore
        bindedHandlers[bindedName] = bindedHandler;
    }

    target.hooks.setHandlers(bindedHandlers);
}

[denis-migdal]

For information:

[K in keyof H as `on${Capitalize<K & string>}`]

Doesn't solve this specific issue, but seems to cause less inference issues compared to:

[K in string&keyof H as `on${Capitalize<K>}`]

I also tested the second issue with:

• K in keyof H as K => (...args: any) => void
• K in Extract<keyof H, string> => (...args: any) => void
• K in keyof Pick<H, string> => (...args: any) => void
• K in string&keyof H => (...args: unknown) => void different
• K in keyof H as K extends string ? K : never => (...args: any) => void
• K in keyof H as K & string => (...args: any) => void

Playground Link