2장: const 타입 파라미터와 satisfies 연산자

function createConfig<T extends Record<string, unknown>>(config: T): T {
  return config;
}
 
const config = createConfig({
  port: 3000,
  host: "localhost",
  debug: true,
});
 
// config의 타입: { port: number; host: string; debug: boolean }
// 우리가 원하는 타입: { port: 3000; host: "localhost"; debug: true }

// 5.0 이전: 호출 측에서 as const 필요
const config = createConfig({
  port: 3000,
  host: "localhost",
  debug: true,
} as const);

function createConfig<const T extends Record<string, unknown>>(config: T): T {
  return config;
}
 
const config = createConfig({
  port: 3000,
  host: "localhost",
  debug: true,
});
 
// config의 타입: { readonly port: 3000; readonly host: "localhost"; readonly debug: true }

function inspect<const T>(value: T): T {
  return value;
}
 
// 1. 리터럴 보존
const a = inspect("hello");    // "hello" (string이 아님)
const b = inspect(42);          // 42 (number가 아님)
 
// 2. 객체 readonly
const c = inspect({ x: 1, y: 2 });
// { readonly x: 1; readonly y: 2 }
 
// 3. 배열 → readonly 튜플
const d = inspect([1, "two", true]);
// readonly [1, "two", true]

type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
 
interface RouteDefinition {
  path: string;
  method: HttpMethod;
}
 
function defineRoutes<const T extends readonly RouteDefinition[]>(routes: T) {
  return {
    routes,
    getRoute<P extends T[number]["path"]>(path: P) {
      return routes.find((r) => r.path === path) as Extract<T[number], { path: P }>;
    },
  };
}
 
const router = defineRoutes([
  { path: "/api/users", method: "GET" },
  { path: "/api/users", method: "POST" },
  { path: "/api/posts/:id", method: "GET" },
]);
 
// path 자동완성: "/api/users" | "/api/posts/:id"
const route = router.getRoute("/api/users");
// route.method: "GET" | "POST"

function createEventMap<
  const T extends Record<string, (...args: any[]) => void>
>(handlers: T) {
  return {
    emit<K extends keyof T>(event: K, ...args: Parameters<T[K]>) {
      handlers[event](...args);
    },
  };
}
 
const events = createEventMap({
  click: (x: number, y: number) => console.log(`Click at ${x}, ${y}`),
  keydown: (key: string) => console.log(`Key: ${key}`),
  resize: (width: number, height: number) => console.log(`${width}x${height}`),
});
 
events.emit("click", 100, 200);     // OK
events.emit("keydown", "Enter");     // OK
events.emit("click", "wrong");       // Error: string은 number에 할당 불가

// 방법 1: 타입 주석 — 타입 검증 O, 리터럴 정보 X
type Colors = Record<string, [number, number, number]>;
const colors: Colors = {
  red: [255, 0, 0],
  green: [0, 255, 0],
  blue: [0, 0, 255],
};
colors.red;      // [number, number, number]
colors.purple;   // 에러 없음 — Record<string, ...>이므로
 
// 방법 2: 타입 추론 — 리터럴 정보 O, 타입 검증 X
const colors2 = {
  red: [255, 0, 0],
  green: [0, 255, 0],
  blue: [0, 0, 2555], // 오타! 하지만 에러 없음
};
colors2.red;     // number[] — 튜플이 아닌 배열
colors2.purple;  // Error — 존재하지 않는 키

type Colors = Record<string, [number, number, number]>;
 
const colors = {
  red: [255, 0, 0],
  green: [0, 255, 0],
  blue: [0, 0, 255],
} satisfies Colors;
 
colors.red;      // [number, number, number] — 검증됨
colors.purple;   // Error — "purple"은 존재하지 않는 키
colors.blue[0];  // number — 안전하게 인덱싱 가능

type Config = { port: number; host: string };
 
// as: 타입 검사 우회 — 위험
const config1 = { port: "3000" } as Config;
// 에러 없음! port가 string인데도 통과
 
// satisfies: 타입 검사 수행 — 안전
const config2 = { port: "3000" } satisfies Config;
// Error: string은 number에 할당할 수 없음

interface DatabaseConfig {
  host: string;
  port: number;
  ssl: boolean;
  poolSize?: number;
}
 
const dbConfig = {
  host: "db.example.com",
  port: 5432,
  ssl: true,
  poolSize: 10,
} satisfies DatabaseConfig;
 
// dbConfig.host: string (검증됨)
// dbConfig.poolSize: number (undefined가 아닌 number — 값이 있으므로)

type State = "idle" | "loading" | "success" | "error";
type Transition = {
  target: State;
  guard?: (context: any) => boolean;
};
 
type StateMachine = Record<State, Record<string, Transition>>;
 
const machine = {
  idle: {
    FETCH: { target: "loading" },
  },
  loading: {
    RESOLVE: { target: "success" },
    REJECT: { target: "error" },
  },
  success: {
    RESET: { target: "idle" },
  },
  error: {
    RETRY: { target: "loading" },
    RESET: { target: "idle" },
  },
} satisfies StateMachine;
 
// machine.loading.RESOLVE.target: "success" (리터럴 타입 보존)
// machine.idle.NONEXISTENT // Error — 존재하지 않는 이벤트

interface MenuItem {
  label: string;
  href: string;
  icon?: string;
}
 
function createMenu<const T extends readonly MenuItem[]>(items: T) {
  return items;
}
 
const menu = createMenu([
  { label: "Home", href: "/" },
  { label: "About", href: "/about" },
  { label: "Blog", href: "/blog", icon: "pencil" },
] satisfies readonly MenuItem[]);
 
// 각 항목의 label, href가 리터럴 타입으로 보존되면서도
// MenuItem 인터페이스를 만족하는지 검증됨
type MenuLabels = (typeof menu)[number]["label"];
// "Home" | "About" | "Blog"

interface TranslationSchema {
  [key: string]: string | TranslationSchema;
}
 
function defineTranslations<const T extends TranslationSchema>(translations: T) {
  return translations;
}
 
const ko = defineTranslations({
  common: {
    save: "저장",
    cancel: "취소",
    delete: "삭제",
  },
  auth: {
    login: "로그인",
    logout: "로그아웃",
    signup: "회원가입",
  },
} satisfies TranslationSchema);
 
// ko.common.save: "저장" (리터럴 타입)
// ko.auth.login: "로그인"
type TranslationKeys = keyof typeof ko; // "common" | "auth"

// 불필요한 satisfies — 이미 타입이 명확한 경우
const port = 3000 satisfies number; // 의미 없음
 
// 불필요한 const — 이미 리터럴 타입인 경우
function identity<const T extends string>(value: T): T {
  return value;
}
// string 리터럴은 기본적으로 좁게 추론되므로 const 불필요