Mastering TypeScript's keyof: Type-Safe Dynamic Properties

interface User {
  id: number;
  name: string;
  email: string;
}

type UserKeys = keyof User;
// Result: "id" | "name" | "email"

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const product = {
  id: "1",
  title: "Laptop",
  price: 999
};

const title = getProperty(product, "title"); // Type: string
const price = getProperty(product, "price"); // Type: number

// ❌ Error
const invalid = getProperty(product, "invalid");

interface FormData {
  username: string;
  email: string;
  age: number;
}

type FormErrors = {
  [K in keyof FormData]?: string;
};

class FormValidator {
  private errors: FormErrors = {};

  setError<K extends keyof FormData>(field: K, message: string) {
    this.errors[field] = message;
  }

  getError<K extends keyof FormData>(field: K) {
    return this.errors[field];
  }
}

// Usage
const validator = new FormValidator();
validator.setError("username", "Too short"); // Type-safe!

interface Events {
  login: { userId: string; timestamp: number };
  logout: { userId: string };
  error: { message: string; code: number };
}

class TypeSafeEventEmitter {
  private listeners: {
    [K in keyof Events]?: Array<(data: Events[K]) => void>;
  } = {};

  on<K extends keyof Events>(
    event: K,
    callback: (data: Events[K]) => void
  ) {
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    this.listeners[event]!.push(callback);
  }

  emit<K extends keyof Events>(event: K, data: Events[K]) {
    this.listeners[event]?.forEach(cb => cb(data));
  }
}

// Usage
const emitter = new TypeSafeEventEmitter();
emitter.on("login", (data) => {
  // data is typed: { userId: string; timestamp: number }
  console.log(`User ${data.userId} logged in`);
});

// Make all properties optional
type Partial<T> = {
  [K in keyof T]?: T[K];
};

// Make all readonly
type Readonly<T> = {
  readonly [K in keyof T]: T[K];
};

// Pick specific properties
type Pick<T, K extends keyof T> = {
  [P in K]: T[P];
};