MapTypes

In this medium-level challenge, you'll implement MapTypes<T, R>, a utility type that transforms the value types of an object T according to mapping rules defined by R, which specifies mapFrom and mapTo pairs.

type StringToNumber = {
mapFrom: string; // value of key which value is string
mapTo: number; // will be transformed for number
}

type StringToNumber = { mapFrom: string; mapTo: number;}
MapTypes<{iWillBeANumberOneDay: string}, StringToNumber> // gives { iWillBeANumberOneDay: number; }

type StringToNumber = { mapFrom: string; mapTo: number;}
type StringToDate = { mapFrom: string; mapTo: Date;}
MapTypes<{iWillBeNumberOrDate: string}, StringToDate | StringToNumber> // gives { iWillBeNumberOrDate: number | Date; }

type StringToNumber = { mapFrom: string; mapTo: number;}
MapTypes<{iWillBeANumberOneDay: string, iWillStayTheSame: Function}, StringToNumber> // // gives { iWillBeANumberOneDay: number, iWillStayTheSame: Function }

type cases = [
  Expect<
    Equal<
      MapTypes<{ stringToArray: string }, { mapFrom: string; mapTo: [] }>,
      { stringToArray: [] }
    >
  >,
  Expect<
    Equal<
      MapTypes<{ stringToNumber: string }, { mapFrom: string; mapTo: number }>,
      { stringToNumber: number }
    >
  >,
  Expect<
    Equal<
      MapTypes<
        { stringToNumber: string; skipParsingMe: boolean },
        { mapFrom: string; mapTo: number }
      >,
      { stringToNumber: number; skipParsingMe: boolean }
    >
  >,
  Expect<
    Equal<
      MapTypes<
        { date: string },
        { mapFrom: string

Detailed Explanation

type MapTypes<T, R extends { mapFrom: any; mapTo: any }> = {
  [K in keyof T]: T[K] extends R['mapFrom']
    ? R extends { mapFrom: T[K]; mapTo: infer To }
      ? To
      : never
    : T[K];
};

How it works:

• The type iterates over each key K in the object T using a mapped type
• For each property, it first checks if the value type T[K] extends any of the mapFrom types in the union R
• If a match is found, it narrows down R to only the union members whose mapFrom matches T[K] exactly, using R extends { mapFrom: T[K]; mapTo: infer To } -- this distributes over the union to collect all matching mapTo types
• The inferred To types are automatically unioned together when multiple mapping rules match the same source type, which handles the case where R is a union like { mapFrom: string; mapTo: Date } | { mapFrom: string; mapTo: null }
• If T[K] does not match any mapFrom in R, the original type is preserved unchanged

This challenge helps you understand distributive conditional types within mapped types, and how to apply these concepts in real-world scenarios.