TypeScript Mapped Types — Transform Types

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

// Make all properties readonly
type ReadonlyUser = {
  readonly [K in keyof User]: User[K];
};

// Make all properties optional
type PartialUser = {
  [K in keyof User]?: User[K];
};

// Make all properties nullable
type NullableUser = {
  [K in keyof User]: User[K] | null;
};

// Make all properties getters
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type UserGetters = Getters<User>;
// {
//   getId: () => number;
//   getName: () => string;
//   getEmail: () => string;
// }

interface APIResponse {
  user_id: number;
  user_name: string;
  user_email: string;
}

// Convert snake_case to camelCase
type Camelcase<T> = {
  [K in keyof T as K extends `${infer Prefix}_${infer Rest}`
    ? `${Prefix}${Capitalize<Rest>}`
    : K]: T[K];
};

type CamelcaseResponse = Camelcase<APIResponse>;
// {
//   userId: number;
//   userName: string;
//   userEmail: string;
// }

// Filter properties by type
type StringPropertiesOnly<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K];
};

type UserStrings = StringPropertiesOnly<User>;
// {
//   name: string;
//   email: string;
// }

// Get only readable properties
type Readable<T> = {
  [K in keyof T]-?: T[K] extends Function ? never : K;
}[keyof T];

interface Mixed {
  name: string;
  getName(): string;
  age: number;
}

type ReadableProps = Readable<Mixed>; // "name" | "age"

// Create getters only for non-function properties
type Accessors<T> = {
  [K in keyof T as T[K] extends Function
    ? never
    : `get${Capitalize<string & K>}`]: T[K] extends Function
    ? never
    : () => T[K];
};

type UserAccessors = Accessors<User>;

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type Setters<T> = {
  [K in keyof T as `set${Capitalize<string & K>}`]: (
    value: T[K]
  ) => void;
};

type GettersAndSetters<T> = Getters<T> & Setters<T>;

class UserClass {
  private data: User = { id: 1, name: "", email: "" };

  getId(): number {
    return this.data.id;
  }

  setId(value: number): void {
    this.data.id = value;
  }

  getName(): string {
    return this.data.name;
  }

  setName(value: string): void {
    this.data.name = value;
  }

  getEmail(): string {
    return this.data.email;
  }

  setEmail(value: string): void {
    this.data.email = value;
  }
}

type UserClassInterface = GettersAndSetters<User>;

// Create a mapping from string to another type
type Permission = "read" | "write" | "delete";

type PermissionFlags = Record<Permission, boolean>;
// {
//   read: boolean;
//   write: boolean;
//   delete: boolean;
// }

// Create a type from a union
type EventMap = {
  "user:created": { userId: number };
  "user:deleted": { userId: number };
  "post:published": { postId: number };
};

type EventListeners<T extends keyof EventMap = keyof EventMap> = {
  [K in T]: (payload: EventMap[K]) => void;
};

const listeners: EventListeners = {
  "user:created": (payload) => console.log(payload.userId),
  "user:deleted": (payload) => console.log(payload.userId),
  "post:published": (payload) => console.log(payload.postId),
};

// Create a proxy handler type
type Proxify<T> = {
  get(target: T, prop: keyof T): T[keyof T];
  set(target: T, prop: keyof T, value: T[keyof T]): boolean;
};

type ProxyObject<T> = {
  [K in keyof T]: T[K];
};

// Extract property names by type
type MethodNames<T> = {
  [K in keyof T]: T[K] extends Function ? K : never;
}[keyof T];

interface DataService {
  getName(): string;
  getAge(): number;
  processData(data: any): void;
}

type Methods = MethodNames<DataService>; // "getName" | "getAge" | "processData"

interface LoginForm {
  email: string;
  password: string;
  rememberMe: boolean;
}

// Create error state
type FormErrors<T> = Partial<Record<keyof T, string>>;

// Create touched state
type FormTouched<T> = Partial<Record<keyof T, boolean>>;

// Create loaded state
type FormLoaded<T> = {
  [K in keyof T]: boolean;
};

// Complete form state
type FormState<T> = {
  values: T;
  errors: FormErrors<T>;
  touched: FormTouched<T>;
  loaded: FormLoaded<T>;
  isSubmitting: boolean;
  isValid: boolean;
};

type LoginFormState = FormState<LoginForm>;

const formState: LoginFormState = {
  values: { email: "", password: "", rememberMe: false },
  errors: { email: "Required" },
  touched: { email: true },
  loaded: { email: true, password: false, rememberMe: false },
  isSubmitting: false,
  isValid: false,
};

// Deep partial
type DeepPartial<T> = T extends object
  ? {
      [P in keyof T]?: DeepPartial<T[P]>;
    }
  : T;

interface Config {
  server: {
    host: string;
    port: number;
    ssl: {
      enabled: boolean;
      cert: string;
    };
  };
}

type PartialConfig = DeepPartial<Config>;
// Can omit any nested property

// Deep readonly
type DeepReadonly<T> = T extends object
  ? {
      readonly [K in keyof T]: DeepReadonly<T[K]>;
    }
  : T;

type ImmutableConfig = DeepReadonly<Config>;
// All nested objects and properties are readonly

// Create event listeners from event names
type Events = "click" | "hover" | "focus";

type EventHandlers = {
  [K in Events as `on${Capitalize<K>}`]: (event: Event) => void;
};

// {
//   onClick: (event: Event) => void;
//   onHover: (event: Event) => void;
//   onFocus: (event: Event) => void;
// }

// Create routes from actions
type Action = "list" | "create" | "update" | "delete";

type Routes = {
  [K in Action as `/${K}`]: (req: any, res: any) => void;
};

// {
//   /list: (req: any, res: any) => void;
//   /create: (req: any, res: any) => void;
//   /update: (req: any, res: any) => void;
//   /delete: (req: any, res: any) => void;
// }

interface UserAPI {
  getUser(id: number): Promise<User>;
  createUser(data: Omit<User, "id">): Promise<User>;
  updateUser(id: number, data: Partial<User>): Promise<User>;
  deleteUser(id: number): Promise<void>;
}

// Create mock methods that return fixed values
type MockAPI<T extends Record<string, (...args: any[]) => any>> = {
  [K in keyof T]: (...args: Parameters<T[K]>) => ReturnType<T[K]>;
};

const mockUserAPI: MockAPI<UserAPI> = {
  getUser: async (id: number) => ({
    id,
    name: "Mock User",
    email: "mock@example.com",
  }),
  createUser: async (data) => ({
    id: 1,
    ...data,
  }),
  updateUser: async (id: number, data: any) => ({
    id,
    name: "Mock User",
    email: "mock@example.com",
    ...data,
  }),
  deleteUser: async () => {},
};