The Type Mapping, or Enum Mapping, pattern is a technique in TypeScript that uses the Record utility type to create objects with key-value pairs that are type-safe.

This pattern is often used to replace multiple conditional statements (if, switch) with a concise and type-safe mapping.

Problem: Utility Function with Multiple Conditionals

Consider a function like this:

type StatusTypeProps = 'A' | 'B' | 'C' | 'D' | 'E';

const getParsedStatusType = ({ statusType }: StatusTypeProps) => {
  if (statusType === 'A') return 'Something';
  if (statusType === 'B') return 'Something';
  if (statusType === 'C') return 'Something';
  if (statusType === 'D') return 'Something';
  if (statusType === 'E') return 'Something';

  return;
};

Functions like this tend to be long, repetitive, and hard to maintain, and type safety is not guaranteed.

Solution: Type Mapping Using Record

You can solve this neatly using TypeScript’s Record utility type:

type StatusTypeProps = 'A' | 'B' | 'C' | 'D' | 'E';

const statusTypeMap: Record<StatusTypeProps, string> = {
  A: 'Something',
  B: 'Something',
  C: 'Something',
  D: 'Something',
  E: 'Something',
};

// Usage
const getParsedStatusType = (statusType: StatusTypeProps) => statusTypeMap[statusType];

Advantages of Record

Record<Key, Value> offers several benefits:

• Type enforcement: Guarantees key and value types at compile time
• Prevents missing keys: Compile-time error if a key is missing
• Blocks invalid keys: Compile-time error if an unknown key is added
• Autocomplete support: IDEs can suggest keys automatically
• Improved maintainability: Manage data rather than conditional logic

In short, conditional statements enumerating all possible cases can be replaced with a type-safe mapping object.

Structure of Record

The Record<K, T> type is defined as:

type Record<K extends keyof any, T> = { [P in K]: T; };

• K (first generic): the key type
• T (second generic): the value type

In the example above, StatusTypeProps is the key type, and string is the value type.