npm install -D expect-type

// package.json (발췌)
{
  "scripts": {
    "test": "vitest run",
    "test:types": "vitest --typecheck --run",
    "coverage": "vitest run --coverage"
  },
  "devDependencies": {
    "expect-type": "^1.4.0"
  }
}

// vitest.config.ts
import { defineConfig } from 'vitest/config'
 
export default defineConfig({
  test: {
    environment: 'jsdom',
    coverage: {
      provider: 'v8',
      include: ['src/services/**'],
    },
    typecheck: {
      enabled: false,
      include: ['src/**/*.test-d.ts'],
    },
  },
})

// src/lib/types/utility.test-d.ts
import { expectTypeOf } from 'expect-type'
import type { DeepPartial, DeepReadonly, ElementOf, FormErrors, JsonValue, UnwrapPromise } from './utility.ts'
 
// UnwrapPromise: 중첩된 Promise를 재귀적으로 풀어낸다
expectTypeOf<UnwrapPromise<Promise<string>>>().toEqualTypeOf<string>()
expectTypeOf<UnwrapPromise<Promise<Promise<number>>>>().toEqualTypeOf<number>()
expectTypeOf<UnwrapPromise<boolean>>().toEqualTypeOf<boolean>()
 
// ElementOf: 배열 타입에서 요소 타입을 뽑아낸다
expectTypeOf<ElementOf<string[]>>().toEqualTypeOf<string>()
expectTypeOf<ElementOf<readonly number[]>>().toEqualTypeOf<number>()
 
// FormErrors: 각 필드 키에 Error 접미사를 붙인 선택적 문자열 맵으로 리매핑한다
type DraftInput = { amount: number; memo: string }
expectTypeOf<FormErrors<DraftInput>>().toEqualTypeOf<{ amountError?: string; memoError?: string }>()
 
// JsonValue: 중첩된 배열·객체까지 재귀적으로 허용한다
expectTypeOf<{ items: [1, 2, { nested: true }] }>().toExtend<JsonValue>()
 
// DeepPartial: 중첩 객체의 모든 단계가 선택적이 된다
type BudgetLimits = { monthly: { food: number; transport: number } }
expectTypeOf<DeepPartial<BudgetLimits>>().toEqualTypeOf<{ monthly?: { food?: number; transport?: number } }>()
 
// DeepReadonly: 중첩 객체의 모든 단계가 readonly가 된다
expectTypeOf<DeepReadonly<BudgetLimits>>().toEqualTypeOf<{
  readonly monthly: { readonly food: number; readonly transport: number }
}>()

// src/lib/types/brand.test-d.ts
import { expectTypeOf } from 'expect-type'
import { toCategoryId, toTransactionId, type CategoryId, type TransactionId } from './brand.ts'
 
// 브랜디드 타입은 원래 원시 타입에는 대입 가능하다(구조적으로 string을 포함)
expectTypeOf<TransactionId>().toExtend<string>()
 
// 하지만 일반 string은 브랜디드 타입에 대입할 수 없다
expectTypeOf<string>().not.toExtend<TransactionId>()
 
// 서로 다른 브랜드끼리도 섞이지 않는다
expectTypeOf<CategoryId>().not.toExtend<TransactionId>()
 
// 헬퍼 함수의 반환 타입이 각각의 브랜드로 고정된다
expectTypeOf(toTransactionId('t-1')).toEqualTypeOf<TransactionId>()
expectTypeOf(toCategoryId('food')).toEqualTypeOf<CategoryId>()

// src/lib/types/pipe.test-d.ts
import { assertType, expectTypeOf } from 'expect-type'
import { pipe } from './pipe.ts'
 
// 함수 하나만 거치면 그 함수의 반환 타입이 된다
const doubled = pipe(2, (n) => n * 2)
expectTypeOf(doubled).toEqualTypeOf<number>()
 
// 여러 함수를 거치면 각 단계의 반환 타입이 다음 단계 입력으로 이어진다
const label = pipe(
  10,
  (n) => n.toString(),
  (s) => `금액: ${s}`,
  (s) => s.length,
)
assertType<number>(label)

npm run test:types

✓ src/lib/types/utility.test-d.ts (6)
✓ src/lib/types/brand.test-d.ts (5)
✓ src/lib/types/pipe.test-d.ts (2)

Type Test Files  3 passed (3)

npm run test