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

Activity

1. denis-migdal commented on Apr 6, 2026

   

   Denis Migdal (denis-migdal)

   on Apr 6, 2026

   Author

   More actions

   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)
   
2. RyanCavanaugh commented on Apr 6, 2026

   

   Ryan Cavanaugh (RyanCavanaugh)

   on Apr 6, 2026

   Member

   More actions

   Why are you writing the function signature this way in the first place?
3. denis-migdal commented on Apr 6, 2026

   

   Denis Migdal (denis-migdal)

   on Apr 6, 2026

   Last edited by denis-migdal

   Author

   More actions

   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);
   }
4. denis-migdal commented on Apr 7, 2026

   

   Denis Migdal (denis-migdal)

   on Apr 7, 2026

   Last edited by denis-migdal

   Author

   More actions

   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
5. Ryan Cavanaugh (RyanCavanaugh)

   added

   Needs InvestigationThis issue needs a team member to investigate its status.This issue needs a team member to investigate its status.

   on Apr 7, 2026
6. Ryan Cavanaugh (RyanCavanaugh)

   added this to the Dormant milestone on Apr 7, 2026