• Empleos
  • Sobre nosotros
  • profesionales
    • Inicio
    • Empleos
    • Cursos y retos
  • empresas
    • Inicio
    • Publicar vacante
    • Nuestro proceso
    • Precios
    • Evaluaciones
    • Nómina
    • Blog
    • Comercial
    • Calculadora de salario

0

206
Vistas
how to aggregate all param types of an object which is an aggregation of functions?

Please take a look at this typescript code :

type params1 = {p:number} ;
type params2 = {p:boolean};
type params3 = {p:string};
type res = {r:string};

const fObject = {
a:(a:params1):res=>{return {r:`${a.p}`}},
b:(a:params2):res=>{return {r:`${a.p?1:0}`}},
c:(a:params3):res=>{return {r:a.p}}
}

How can we create a type that looks like this:

type params = params1 | params2 | params3

I'm creating a new object that will be all the functions of fObject but will run a logger function on the result of each function

like so:

const loggingObject: typeof fObject = Object.keys(fObject).reduce(
 (result: any, key: string) => {
   result[key] = (args: any/*reason for Q*/) => logger.report(fObject
  [key as loggingObject](args /*If i put something like 2 it says it has no properties in common with params1 & param2 & param3, thats why I know its possible*/));
   return result;
  },
  {},
);

I don't want the any type and need a dynamic type that can take an object with function and give a union of all param types of all the function in the object

almost 3 years ago · Juan Pablo Isaza
1 Respuestas
Responde la pregunta

0

Great question. This is possible--in multiple ways! In this solution we will use the following techniques:

  • Mapped Types
  • Conditional Types

The links might be helpful if you want to drill down a bit and if my explanations are not coherent enough. In the end we will have a type that works like so:

// your code here...
type MyParams = ParamForKeys<typeof fObject>;
// => `type MyParams = param1 | param2 | param3`

So what we're going to do is to map over the keys of fObject, and replace each key with the argument type of its function. Mapping over keys looks like this:

type MyParams<T> = { [key in keyof T]: ... }

Now we want to extract the argument type. This will use Conditional Types. Conditional types allow us to do conditions, as well as extract an argument by using inference, with the infer key:

type UnwrapPromise<T> = T extends Promise<infer Inner> ? Inner : never;
type A = UnwrapPromise<Promise<number>> // => number
type B = UnwrapPromise<number> // => never

And that's the exact method we're going to use:

type GetFirstParam<T> = T extends ((param: infer Param) => any) ? Param : never

And now if we build this together we will get:

type GetFirstParam<T> = T extends ((param: infer Param) => any) ? Param : never
type ParamForKeys<T> = { [key in keyof T]: GetFirstParam<T[key]> }

but that gives us the following type:

type MyParams = ParamForKeys<typeof fObject>;
// { a: param1, b: param2, c: param3 }

To get the values back in a union format (param1 | param2 | param3) we can access them like so:

type GetFirstParam<T> = T extends ((param: infer Param) => any) ? Param : never
type ParamForKeys<T> = { [key in keyof T]: GetFirstParam<T[key]> }[keyof T]

And that's the solution. Keep in mind that I'm not sure that this solution is what you're looking for: having the {a: param1, b:param2} makes more sense to me in terms of your logging situation, but that's the solution for you question!

Hope that it was clear. You can see it live in this TypeScript playground.

almost 3 years ago · Juan Pablo Isaza Denunciar
Responde la pregunta
Encuentra empleos remotos

¡Descubre la nueva forma de encontrar empleo!

Top de empleos
Top categorías de empleo
Empresas
Publicar vacante Precios Nuestro proceso Comercial
Legal
Términos y condiciones Política de privacidad
© 2025 PeakU Inc. All Rights Reserved.

Andres GPT

Recomiéndame algunas ofertas
Necesito ayuda