有没有办法在创建另一个 object 类型时使用 object 类型的特定值

Question

The example is for defining a QuestionMap and AnswerMap . There are multiple types of questions that produce different types of answers. So, in order to define the map of answers, you must know the question. Here's an example:

const questionMap: QuestionMap = {
  QUESTION_1: { type: 'boolean' },
  QUESTION_2: { type: 'string' }
  QUESTION_3: { type: 'dropdown', options: { CUSTOM: 'custom answer', UNUSED: 'unused answer' }}
}
const answerMap: Answer<QuestionMap> = {
  QUESTION_1: true,
  QUESTION_2: 'custom answer'
}

In this best attempt for the type of AnswerMap , it doesn't use the Answer type for a specific question.

type AnswerMap<TQuestionMap extends QuestionMap> = Partial<Record<QuestionId, Answer<TQuestionMap[QuestionId]>>>

What is the correct definition for AnswerMap that properly types each answer based on the question's type?

Answer 1

I'm going to guess about your QuestionMap type... well, actually I'm going to eliminate it because it doesn't help me much in my answer. First of all, if you want to enforce that answerMap corresponds to the particular questions from questionMap , you should not annotate questionMap at all. Doing so would end up widening the type of questionMap to something that forgets entirely about these particulars, much the way saying const str: string = "hello" will forget that str is the string literal "hello" and only remember that it is a string .

In fact, instead of annotating, I suggest using a const assertion so that the compiler keeps track of every single string literal in it:

const questionMap = {
    QUESTION_1: { type: 'boolean' },
    QUESTION_2: { type: 'string' },
    QUESTION_3: { type: 'dropdown', options: { CUSTOM: 'custom answer', UNUSED: 'unused answer' } }
} as const;

If you check the type of questionMap you'll see what I mean:

/* const questionMap: {
    readonly QUESTION_1: {
        readonly type: "boolean";
    };
    readonly QUESTION_2: {
        readonly type: "string";
    };
    readonly QUESTION_3: {
        readonly type: "dropdown";
        readonly options: {
            readonly CUSTOM: "custom answer";
            readonly UNUSED: "unused answer";
        };
    };
} */

So now the compiler knows enough about questionMap to process it. But what processing should be done?

---

I'm going to assume that you have some number of "simple" question types, where the question is specified as {type: "someString"} and the answer is a single type depending on "someString" . Let's tell the compiler about them:

type SimpleQuestionTypes = {
    boolean: boolean;
    string: string;
    number: number;
}

And then I'm going to say that a Question type is either one of those, or the "dropdown" type which needs to specify some options :

type Question = { type: keyof SimpleQuestionTypes } | { type: "dropdown", options: any };

This may not be strict enough for your use cases, and possibly you have other question types, but this should suffice for your example code at least.

---

Okay, now let's figure out how to take a type T extending Question and turn it into the expected answer type:

type Answer<T extends Question> =
    T['type'] extends keyof SimpleQuestionTypes ? SimpleQuestionTypes[T['type']] :
    'options' extends keyof T ? T['options'][keyof T['options']] :
    never;

If T has a type property corresponding to one of the simple question types, we will just read the answer type out of SimpleQuestionTypes . Otherwise, if there is an options property, we will grab a union of all the property value types of that options property.

Finally, AnswerMap just maps that Answer computation over each property of an object:

type AnswerMap<T extends Record<keyof T, Question>> = {
    [K in keyof T]: Answer<T[K]>
} // extends infer O ? { [K in keyof O]: O[K] } : never;
// uncomment the above if you want to see easier-to-read output types

---

Now, the type of answerMap should be AnswerMap<typeof questionMap> , where we are using the TypeScript typeof type query operator to get that exact type of questionMap . Like this:

const answerMap: AnswerMap<typeof questionMap> = {
    QUESTION_1: true,
    QUESTION_2: 'str',
    QUESTION_3: 'custom answer'
}

By the way, if we inspect this type, it is equivalent to the following:

/* const answerMap: {
    readonly QUESTION_1: boolean;
    readonly QUESTION_2: string;
    readonly QUESTION_3: "custom answer" | "unused answer";
} */

which is presumably what you're going for. Just to be sure, let's look at what fails when you give bad values for answerMap :

const badAnswerMap1: AnswerMap<typeof questionMap> = { // error!
    QUESTION_1: true,
    QUESTION_2: 'str',
}; // Property 'QUESTION_3' is missing

const badAnswerMap2: AnswerMap<typeof questionMap> = {
    QUESTION_1: true,
    QUESTION_2: 'str',
    QUESTION_3: 'custom answer',
    QUESTION_4: 'str' // error! object literal may only specify known properties
}

const badAnswerMap3: AnswerMap<typeof questionMap> = {
    QUESTION_1: "oops", // error! string is not assignable to boolean
    QUESTION_2: 'str',
    QUESTION_3: 'custom answer',
}

const badAnswerMap4: AnswerMap<typeof questionMap> = {
    QUESTION_1: true,
    QUESTION_2: 'str',
    QUESTION_3: 'custom anwser', // error! "custom anwser" is not assignable to "custom answer" | "unused answer"
}

Looks right to me. Hopefully that's enough to help you proceed with your actual use case.

Playground link to code