Alexander Nenashev's questions

Tentando fazer um método estático que aceite apenas nomes de prop de método de instância, infelizmente sem ideias de como fazer isso funcionar com o seguinte caso. Alguma ideia (por favor, sem asserção de tipo na assinatura de chamada)?

Parque infantil

type MethodKeys<T extends object> = keyof { [K in keyof T as T[K] extends (...args: any) => any ? K : never]: unknown };

class Model{ 
    static chainMethod<C extends typeof Model, T extends InstanceType<C>, K extends MethodKeys<T>>
        (this: C, name: K, method: T[K]) {
        
        }
    method(){

    }
}

class Party{
    static addProps<C extends typeof Model>(model: C){
        model.chainMethod('method', function(){ // error

        })
    }
}

Outra tentativa:

Parque infantil

class Model{ 
    static chainMethod<C extends typeof Model, T extends InstanceType<C>, K extends keyof T, F extends T[K] extends (...args: any) => any ? T[K]: never>
        (this: C, name: K, method: F) {
        
        }
    method(){

    }
}

class Party{
    static addProps<C extends typeof Model>(model: C){
        model.chainMethod('method', function(){

        })
    }
}

ATUALIZAÇÃO
Matt Kantor resolveu a segunda solução, mas eu ainda preferiria a primeira, onde o preenchimento automático mostraria apenas nomes de métodos

Por exemplo, tenho um método estático genérico em uma classe e quero obter seu tipo de parâmetro dado o argumento genérico:

class Model{
    id = 0;
    title = 'test';
}

class Child extends Model{
    child = true;
}

class Foo {

    static func<T extends Model>(a: Omit<T, 'id'>): number{
        return 0;
    }

}

type p = Parameters<typeof Foo['func']>[0] // how to get Child here?

Alguma maneira de conseguir isso? Alguma sintaxe adequada?

Parque infantil

Eu tenho um componente suspenso de lista que aceita itemsadereços que podem ser um objeto/matriz reativo ou não reativo. Então eu watchreajo quando os itens mudam. Mas quando eu forneço uma matriz/objeto estático não reativo, ele emite um aviso de que um valor não reativo é fornecido watch(). Sim, não me importo de observar um valor não reativo.