타입 좁히기와 고급 패턴 — 조건부 타입, 맵드 타입

function processInput(input: string | number | null) {
    // typeof 가드
    if (typeof input === "string") {
        return input.toUpperCase();   // string
    }
    if (typeof input === "number") {
        return input.toFixed(2);      // number
    }
    return "없음";                    // null
}

class ApiError extends Error {
    constructor(public status: number, message: string) {
        super(message);
    }
}

class NetworkError extends Error {
    constructor(public retryAfter: number, message: string) {
        super(message);
    }
}

function handleError(error: ApiError | NetworkError) {
    if (error instanceof ApiError) {
        console.log(`API 오류 ${error.status}: ${error.message}`);
    } else {
        console.log(`네트워크 오류, ${error.retryAfter}초 후 재시도`);
    }
}

interface Loading {
    status: "loading";
}
interface Success<T> {
    status: "success";
    data: T;
}
interface Error {
    status: "error";
    message: string;
}

type AsyncState<T> = Loading | Success<T> | Error;

function render<T>(state: AsyncState<T>): string {
    switch (state.status) {
        case "loading": return "로딩 중...";
        case "success": return JSON.stringify(state.data);  // state.data 접근 가능
        case "error":   return `오류: ${state.message}`;   // state.message 접근 가능
    }
}

interface Cat { type: "cat"; meow(): void }
interface Dog { type: "dog"; bark(): void }
type Animal = Cat | Dog;

// 반환 타입에 "is" 키워드
function isCat(animal: Animal): animal is Cat {
    return animal.type === "cat";
}

function makeSound(animal: Animal) {
    if (isCat(animal)) {
        animal.meow();  // Cat으로 좁혀짐
    } else {
        animal.bark();  // Dog로 좁혀짐
    }
}

// T가 string이면 string[], 아니면 T[]
type ArrayOf<T> = T extends string ? string[] : T[];

type StringArray = ArrayOf<string>;   // string[]
type NumberArray = ArrayOf<number>;   // number[]

// NonNullable 직접 구현
type MyNonNullable<T> = T extends null | undefined ? never : T;

type A = MyNonNullable<string | null | undefined>;  // string

// 함수 반환 타입 추출 (infer)
type UnpackPromise<T> = T extends Promise<infer U> ? U : T;
type Resolved = UnpackPromise<Promise<string>>;  // string
type NotPromise = UnpackPromise<number>;          // number

// Readonly 직접 구현
type MyReadonly<T> = {
    readonly [K in keyof T]: T[K];
};

// Optional 직접 구현
type MyPartial<T> = {
    [K in keyof T]?: T[K];
};

// 깊은 Readonly (재귀)
type DeepReadonly<T> = {
    readonly [K in keyof T]: T[K] extends object
        ? DeepReadonly<T[K]>
        : T[K];
};

interface Config {
    server: { host: string; port: number };
    database: { url: string };
}

type FrozenConfig = DeepReadonly<Config>;
// config.server.host = "...";  // ❌

type EventName = "click" | "focus" | "blur";
type HandlerName = `on${Capitalize<EventName>}`;
// "onClick" | "onFocus" | "onBlur"

type ApiRoute = `/api/${string}`;
const route: ApiRoute = "/api/users";    // ✅
// const bad: ApiRoute = "/users";       // ❌

// CSS 속성 조합
type CSSUnit = "px" | "rem" | "em" | "%";
type CSSValue = `${number}${CSSUnit}`;
const fontSize: CSSValue = "16px";      // ✅

interface Events {
    userLogin: { userId: string; timestamp: Date };
    userLogout: { userId: string };
    itemAdded: { itemId: string; quantity: number };
}

type EventHandler<T extends keyof Events> = (data: Events[T]) => void;

class EventEmitter {
    private handlers: Partial<{
        [K in keyof Events]: EventHandler<K>[];
    }> = {};

    on<T extends keyof Events>(event: T, handler: EventHandler<T>) {
        if (!this.handlers[event]) this.handlers[event] = [];
        (this.handlers[event] as EventHandler<T>[]).push(handler);
    }

    emit<T extends keyof Events>(event: T, data: Events[T]) {
        this.handlers[event]?.forEach(h => h(data));
    }
}

const emitter = new EventEmitter();
emitter.on("userLogin", ({ userId, timestamp }) => {
    console.log(`${userId} 로그인: ${timestamp}`);
});