In Typescript, how do I map a Union type into a { UnionMemberProp1: OptionalUnionMemberProp2 } type?

Question

I've looked at other answers that appear to be asking a simplified version of my question, but I can't figure out how to apply them to my specific question. The following code shows what I'm trying to achieve:

type MyStructTrue = {
  future_key: string;
  future_value: true;
};

type MyStructFalsy = {
  future_key: string;
  future_value?: false;
};

type MyStruct = MyStructTrue | MyStructFalsy;

const myStructArray = [
  { future_key: 'true1', future_value: true },
  { future_key: 'false1', future_value: false },
  { future_key: 'false2', future_value: undefined },
  { future_key: 'false3' },
] as const satisfies readonly MyStruct[];

type MyStructUnion = (typeof myStructArray)[number];

// I want to build a type of:

// type KeyValues = {
//   'true1': 'yes',
//   'false1': number,
//   'false2': number,
//   'false3': number,
// }

type KeyValues = {
  // ^?
  [K in MyStructUnion as MyStructUnion['future_key']]: K extends {
    future_value: true;
  }
    ? 'yes'
    : number;
};

To me it appears that K extends { future_value: true; } ? ... is applied to all possibilities of MyStructUnion instead of individual members. As a result, every value of KeyValues is 'yes' | number. But I want it to apply that conditional to specific union members to get the type I describe in my code's comment.

I think part of the solution is to use a Distributive Conditional Type, but the type signature of MyStructFalsy seems to interfere: future_value may not exist as a property so I am unable to access it in a conditional. I haven't figured out a way to wrap anything in Required<...> to prevent this.

How do I achieve the KeyValues type signature in my comment?

Answer 1

As you mentioned in the description, the condition is applied to all possibilities, not to a single member of a union. To fix we should distribute the union, which is possible when we check K extends K. Alternatively you could use K extends any or K extends unknown.

If this condition is true, the following code will be executed for each member of the union separately:

{
   [P in K["future_key"]]: true extends K["future_value" & keyof K]
      ? "yes"
      : number;
}

Since, "future_value" doesn't exist in all members of the union, the K isn't inferred to have it as a key. By writing "future_value" & keyof K I'm telling Typescript to take the intersection of these two, and if there is no "future_value" in keyof K the intersection will result in never, which will result in K[never], which will result in never. Otherwise, the intersection will be "future_value" itself.

If we now write type Result = KeyValues we will get the following type:

{
    true1: "yes";
} | {
    false1: number;
} | {
    false2: number;
} | {
    false3: number;
}

This type is the expected behavior; however, we need an intersection for your expected result, not a union. We can use the type mentioned in here. New version:

type KeyValues<K extends MyStructUnion = MyStructUnion> = UnionToIntersection<
  K extends K
    ? {
        [P in K["future_key"]]: true extends K["future_value" & keyof K] ? "yes" : number;
      }
    : never
>;

Now type Result = KeyValues will result:

{
    true1: "yes";
} & {
    false1: number;
} & {
    false2: number;
} & {
    false3: number;
}

This is the desired result, however, it doesn't look pretty; that's why we will wrap the whole KeyValues type with the following type that makes the intersections disappear by redefining the object:

type Prettify<T> = T extends infer R ? {[K in keyof R]: R[K]} : never;

Final code:

type KeyValues<K extends MyStructUnion = MyStructUnion> = Prettify<
  UnionToIntersection<
    K extends K
      ? {
          [P in K["future_key"]]: true extends K["future_value" & keyof K]
            ? "yes"
            : number;
        }
      : never
  >
>;

/*
type Result = {
    true1: "yes";
    false1: number;
    false2: number;
    false3: number;
}
*/
type Result = KeyValues;

playground