Mapped types: Make property required based on whether array of same object contains string literal

Question

Is it possible to make an object property dependent on whether an array of the same object contains a string literal?

type Operator = "A" |  "B"
type SomeStruct = {
    operators: Operator[];
    someProp: string; // this should be required if operators include "A", optional if not
}

// desired result
const structWithA: SomeStruct = {
  operators: ["A", "B"],
  someProp: "" // correct, since operators contains "A", someProp is required
};

const structWithB: SomeStruct = {
  operators: ["B"],
  // currently errors, but desired outcome is that it should not error, since operators does not contain "A"
};

declare const structs: SomeStruct[];

structs.map(struct => {
  if(struct.operators.includes("A")) {
    // someProp is safely accessible
  }

  // since .includes has a narrow type signature, maybe another way to safely access someProp is needed 
})

Answer 1

By using an identity function to create your structs (and a predicate to discriminate its type), you can accomplish this:

TS Playground

type A = 'A';
type B = 'B';
type Operator = A | B;

type SomeStruct<T extends readonly Operator[]> = { operators: T; } & (
  T extends readonly A[] ?
    Record<'someProp', string>
    : unknown
);

function craeteStruct <O extends readonly Operator[], T extends SomeStruct<O>>(struct: T): T {
  return struct;
}

const structWithA = craeteStruct({
  operators: ["A", "B"],
  someProp: "",
});

const structWithB = craeteStruct({
  operators: ["B"],
});

declare const structs: (SomeStruct<Operator[]>)[];

function includesA (struct: SomeStruct<Operator[]>): struct is SomeStruct<A[]> {
  return struct.operators.includes('A');
}

structs.map(struct => {
  if(includesA(struct)) {
    struct.someProp; // string
  }
});