조건부 타입과 제네릭

// IsNumber<T>는 T가 number에 할당 가능하면 T를, 아니면 string을 반환합니다.
type IsNumber<T> = T extends number ? T : string;

type Type1 = IsNumber<10>;       // Type1 = 10 (number 리터럴 타입)
type Type2 = IsNumber<number>;   // Type2 = number
type Type3 = IsNumber<string>;   // Type3 = string
type Type4 = IsNumber<boolean>;  // Type4 = string

// T에 num 속성이 있으면 그 속성의 타입을 반환합니다. number 타입으로 제한하지는 않습니다.
// 그렇지 않다면 T 자체를 반환합니다.
type GetNumberProperty<T> = T extends { num: infer N } ? N : T;

type Type5 = GetNumberProperty<{ num: 123 }>;    // Type5 = 123
type Type6 = GetNumberProperty<{ num: number }>; // Type6 = number
type Type7 = GetNumberProperty<{ value: string }>; // Type7 = { value: string; }
type Type8 = GetNumberProperty<string[]>;       // Type8 = string[]

// NonNullAndUndefined<T>는 T가 null 또는 undefined이면 never를, 아니면 T를 반환합니다.
// 즉, T에서 null과 undefined를 제거합니다.
type NonNullAndUndefined<T> = T extends null | undefined ? never : T;

type MixedUnion = string | number | null | undefined | boolean;

// NonNullAndUndefined<MixedUnion>은 다음과 같이 분산되어 처리됩니다.
// (NonNullAndUndefined<string> | NonNullAndUndefined<number> | NonNullAndUndefined<null> | NonNullAndUndefined<undefined> | NonNullAndUndefined<boolean>)
// 결과: (string | number | never | never | boolean)
type CleanedUnion = NonNullAndUndefined<MixedUnion>;
// type CleanedUnion = string | number | boolean

// Exclude<T, U>의 모의 구현 (T에서 U에 할당 가능한 타입을 제외)
type MyExclude<T, U> = T extends U ? never : T;

type Statuses = "active" | "inactive" | "pending" | "deleted";
type CurrentStatuses = MyExclude<Statuses, "deleted">;
// type CurrentStatuses = "active" | "inactive" | "pending"
// Statuses의 각 멤버가 "deleted"에 할당 가능한지 검사합니다.
// ("active" extends "deleted" ? never : "active") => "active"
// ("inactive" extends "deleted" ? never : "inactive") => "inactive"
// ("pending" extends "deleted" ? never : "pending") => "pending"
// ("deleted" extends "deleted" ? never : "deleted") => never
// 결과: "active" | "inactive" | "pending" | never => "active" | "inactive" | "pending"

// UnwrapPromise<T>는 Promise<U> 형태의 타입 T에서 U를 추출합니다.
// 만약 T가 Promise<any> 형태가 아니라면 T 자체를 반환합니다.
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

type P1 = UnwrapPromise<Promise<string>>;       // P1 = string
type P2 = UnwrapPromise<Promise<Promise<number>>>; // P2 = Promise<number> (한 단계만 벗겨냄)
type P3 = UnwrapPromise<string>;                 // P3 = string

// DeepUnwrapPromise<T>는 재귀적으로 Promise를 벗겨내어 최종 값을 추출합니다.
type DeepUnwrapPromise<T> = T extends Promise<infer U> ? DeepUnwrapPromise<U> : T;

type DP1 = DeepUnwrapPromise<Promise<string>>;       // DP1 = string
type DP2 = DeepUnwrapPromise<Promise<Promise<number>>>; // DP2 = number
type DP3 = DeepUnwrapPromise<string>;                 // DP3 = string

interface UserResponse {
  id: number;
  name: string;
}

// GetPayload<T>는 T가 { payload: infer P } 형태를 가지면 P를 추출합니다.
type GetPayload<T> = T extends { payload: infer P } ? P : never;

type ApiSuccessResponse = { status: "success"; payload: UserResponse };
type ApiErrorResponse = { status: "error"; message: string };

type SuccessPayload = GetPayload<ApiSuccessResponse>; // SuccessPayload = UserResponse
type ErrorPayload = GetPayload<ApiErrorResponse>;     // ErrorPayload = never (payload 속성이 없으므로)

type ApiResponse = ApiSuccessResponse | ApiErrorResponse;
type WholeGetPayload<T> = [T] extends [{ payload: infer P }] ? P : never;

type ExtractedPayload = GetPayload<ApiResponse>;
type WholePayload = WholeGetPayload<ApiResponse>;