Revision history [back]

To map a deep partial in Typescript to another deep partial, you can use a combination of Partial and Record types along with the keyof operator.

Here is an example code snippet:

type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends (infer U)[] ? DeepPartial<U>[] : DeepPartial<T[P]>;
};

interface Person {
  name: string;
  age: number;
  address: {
    street: string;
    city: string;
    zipcode: string;
  };
}

type PartialPerson = DeepPartial<Person>;

function mapPartialPerson(partialPerson: PartialPerson): PartialPerson {
  const result: PartialPerson = {};

  for (const key in partialPerson) {
    if (partialPerson.hasOwnProperty(key)) {
      const value = partialPerson[key];

      if (typeof value === "object" && value !== null) {
        result[key] = mapPartialPerson(value);
      } else {
        result[key] = value;
      }
    }
  }

  return result;
}

const partialPerson: PartialPerson = {
  name: "John",
  address: {
    city: "New York",
  },
};

const mappedPartialPerson = mapPartialPerson(partialPerson);

console.log(mappedPartialPerson);
// Output: { name: 'John', address: { city: 'New York' } }

In this example, we define the DeepPartial type that recursively makes each property optional in a given type. Then, we define the mapPartialPerson function that takes a PartialPerson as input and returns another PartialPerson object by recursively mapping all its nested properties.

Note that in the mapPartialPerson function, we check if the property value is an object and recursively call the mapPartialPerson function on it if it is. Otherwise, we just assign the value to the result object.