Change type of values in deeply nested object structure

Question

I need to recursively get through the data structure and create a type that has some of the fields changed to a different type, based on a condition.

Based on the following structure, I need to create a type (Result) where all A types are replaced with B types.

class A{}
class B{}

const data = {
    propA:new AA,
    propB:true,
    nested:{
        propC:new AA,
        propD:false
    }
}

// something like:
type Replace<typeof data, A, B>

// result
type Result = {
    propA:B,
    propB:boolean,
    nested:{
        propC:B
        propD:boolean
    }

}

Oblosys · Accepted Answer · 2021-04-19 23:33:40Z

3

You can do this with a mapped type, but keep in mind that matching is based on object structure rather than class name, so an object from a class C{} will also get converted when you're targeting A.

The Replace type can be defined as

type Replace<T, From, To> = T extends (...args: any[]) => any ? T : {
  [K in keyof T]: 
    [T[K], From] extends [From, T[K]] ? To : Replace<T[K], From, To>
}

The first condition is to preserve any methods/function properties as mapped types will convert these to {}. The mapped type itself processes each key, and checks whether both value extends the From type and the From type extends the value type, to ensure equality. If both are equal, the value gets replaced with To, and otherwise Replace is called recursively.

Here's an example conversion:

class A{}
class B{b = 42}
class C{}

const data = {
    propA: new A(),
    propBool: true,
    propC: new C(),
    nested:{
        propA: new A(),
        propBool: false
    },
    f: () => 42
}

type Result = Replace<typeof data, A, B>
// type Result = {
//     propA: B;
//     propBool: boolean;
//     propC: B;
//     nested: {
//         propA: B;
//         propBool: boolean;
//     };
//     f: () => number;
// }

TypeScript playground

answered Apr 19, 2021 at 23:33

Oblosys

15.2k3 gold badges33 silver badges41 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Joey Kilpatrick Over a year ago

Why is it necessary to check that From extends T[K]?

Oblosys Over a year ago

@JoeyKilpatrick To avoid also replacing subtypes of From. If From is {a: 1} for example, then without the extra condition it would also replace {a:1, b:2}.

Joey Kilpatrick Over a year ago

That is certainly a strength of your answer over my own. Also, I had never seen the use of tuples to effectively check multiple extends conditions together, very clever. Upvote from me.

Ivan V. Over a year ago

Never knew you could check for multiple extends. Advanced Typescript looks like magic.

Joey Kilpatrick · Accepted Answer · 2021-04-19 23:34:32Z

1

This can be achieved with conditional, recursive types:

class A {
    ClassPropA!: string
}
class B {
    ClassPropB!: string
}

const data = {
    propA: new A(),
    propB: true,
    nested:{
        propC: new A(),
        propD:false
    }
}

type Replace<T, A, B> = T extends object
    ? { [key in keyof T]: T[key] extends A ? B : Replace<T[key], A, B> }
    : T;

// type Result = {
//     propA: B,
//     propB: boolean,
//     nested:{
//         propC: B
//         propD: boolean
//     }
//
// }
type Result = Replace<typeof data, A, B>;

edited Apr 19, 2021 at 23:34

answered Apr 19, 2021 at 23:28

Joey Kilpatrick

1,61212 silver badges20 bronze badges

1 Comment

Ivan V. Over a year ago

This answer is also correct, and it's easier to reason about, however, I'm going with the @Oblosys answer since it includes that additional check. So just an upvote from me this time.

Collectives™ on Stack Overflow

Change type of values in deeply nested object structure

2 Answers 2

4 Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related