6장 고급 타입

type ExistingUser = {
  id: number
  name: string
}

type NewUser = {
  name: string
}

function deleteUser(user: { id?: number; name: string }) {
  delete user.id
}

const user: ExistingUser = {
  id: 1,
  name: "john doe",
}

deleteUser(user)
console.info(user.id) // undefined

type LegacyUser = {
  id?: number | string
  name: string
}

const legacy: LegacyUser = {
  id: "12312",
  name: "Jane Doe",
}

const legacy2: LegacyUser = {
  id: 12312,
  name: "James Doe",
}

deleteUser(legacy)
deleteUser(legacy2)
/*
Argument of type 'LegacyUser' is not assignable to parameter of type 
	'{ id?: number | undefined; name: string; }'.
Types of property 'id' are incompatible.
Type 'string | number | undefined' is not assignable to type 
	'number | undefined'.
Type 'string' is not assignable to type 'number | undefined'.ts(2345)
*/

interface A {
  name: string
  id: string
  children: object
}

interface B extends A {
  name: "John Doe" | "Jane Doe"
  id: "james Doe" | "Kill"
  children: number[]
}

const toStr = (obj: A) => {
  console.log(obj.id, obj.name, ...Object.values(obj))
}

const toStr2 = (obj: B) => {
  console.log(obj.id, obj.name, ...Object.values(obj))
}

const a: B = {
  name: "Jane Doe",
  id: "james Doe",
  children: [1, 2, 3, 4],
}

const b: A = {
  name: "Jane Doe",
  id: "james Doe",
  children: [1, 2, 3, 4],
}

toStr(a)
toStr2(b) // error

/*
Argument of type 'A' is not assignable to parameter of type 'B'.
  Types of property 'name' are incompatible.
    Type 'string' is not assignable to type '"John Doe" | "Jane Doe"'.ts(2345)
*/

function user(a: string, b: string, c: number): void {
  console.log(a, b, c)
}

function user2(a: string, b: string, c: number, d: boolean): void {
  console.log(a, b, c, d)
}

function user3(a: string, b: string): void {
  console.log(a, b)
}

function po(fn: (a: string, b: string, c: number) => void, num: number) {}

po(user, 3)
po(user2, 2)
po(user3, 2)

class Animal {}

class Bird extends Animal {
  chirp() {}
}

class Crow extends Bird {
  caw() {}
}

function chirp(bird: Bird) {
  bird.chirp()
  return bird
}

chirp(new Animal()) // error 발생
chirp(new Bird())
chirp(new Crow())

function clone(f: (b: Bird) => Bird): void {}
function birdToBird(b: Bird): Bird {
  return b
}

clone(birdToBird)

function birdToCrow(d: Bird): Crow {
  console.log(d)
  return new Crow()
}

clone(birdToCrow)

function birdToAnimal(d: Bird): Animal {
  console.log(d)
  return new Animal()
}

clone(birdToAnimal) // 에러 발생

function animalToBird(a: Animal): Bird {
  console.log(a)
  return new Bird()
}

function crowToBird(a: Crow): Bird {
  console.log(a)
  return new Bird()
}

clone(animalToBird) // 에러발생
clone(crowToBird)

type Options = {
  baseURL: string
  cacheSize?: number
  tier: "prod" | "dev"
}

class API {
  constructor(private opitons: Options) {}
}

new API({
  baseURL: "https://api.mysite.com",
  tier: "prod",
})

new API({
  baseURL: "https://api.mysite.com",
  tierr: "prod",
}) // error

type Unit = "cm" | "px" | "%"

let units: Unit[] = ["cm", "px", "%"]

function parseUnit(value: string): Unit | null {
  for (let i = 0; i < units.length; i++) {
    if (value.endsWith(units[i])) {
      return units[i]
    }
  }
  return null
}

type Width = {
  unit: Unit
  value: number
}

function parseWidth(width: number | string | null | undefined): Width | null {
  if (width === null || typeof width === "undefined") {
    return null
  }

  if (typeof width === "number") {
    return {
      unit: "px",
      value: width,
    }
  }

  const unit = parseUnit(width)
  if (!unit) {
    return null
  }

  return { unit, value: parseFloat(width) }
}

type UserTextEvent = {
  value: string
  target: HTMLInputElement
}

type UserMouseEvent = {
  value: [number, number]
  target: HTMLElement
}

type UserEvent = UserTextEvent | UserMouseEvent

function handle(event: UserEvent) {
  if (typeof event.value === "string") {
    event.value // string
    event.target // UserTextEvent | UserMouseEvent;
    return
  }
  event.value // [number, number];
  event.target // UserTextEvent | UserMouseEvent;
  return
}

type UserTextEvent = {
  type: "TextEvent"
  value: string
  target: HTMLInputElement
}

type UserMouseEvent = {
  type: "MouseEvent"
  value: string
  target: HTMLElement
}

type UserEvent = UserTextEvent | UserMouseEvent

function handle(event: UserEvent) {
  if (event.type === "TextEvent") {
    event.target // HTMLInputElement
    return
  }
  event.target // HTMLElement
}

type Weekday = "MON" | "TUE" | "WED" | "THU" | "FRI"
type Day = Weekday | "SAT" | "SUN"

function getNextDay(w: Weekday): Day {
  /*
Function lacks ending return statement and return type does not include 
'undefined'.ts(2366)
type Day = Weekday | "SAT" | "SUN"
*/
  switch (w) {
    case "MON":
      return "THU"
  }
}

function isBig(n: number) {
  /*
Not all code paths return a value.ts(7030)
function isBig(n: number): true | undefined
*/
  if (n >= 100) {
    return true
  }
}

type APIResponse = {
  user: {
    userId: string
    friendList: {
      count: number
      friends: {
        firstName: string
        lastName: string
      }[]
    }
  }
}

function getAPIResponse(): Promise<APIResponse> {
  //....
}

function renderFriendList(friendList: unknown) {
  //
}
let response = await getAPIResponse()
renderFriendList(response.user.friendList)

// friendList type ?

// #1. type All
type FriendList = {
  count: number
  friends: {
    firstName: string
    lastName: string
  }[]
}

type APIResponse = {
  user: {
    userId: string
    friendList: FriendList
  }
}

function renderFriendList(friendList: FriendList) {
  //...
}

// #2. use key in

type FriendList = APIResponse["user"]["friendList"]

type ResponseKeys = keyof APIResponse // user: string
type UserKeys = keyof APIResponse["user"] // 'userId' | 'friendList'
type FriendListKeys = keyof APIResponse["user"]["friendList"]
// 'count' | 'friends'

function get<O extends object, K extends keyof O>(o: O, k: K): O[K] {
  return o[k]
}

type Get = {
  <O extends object, K1 extends keyof O>(o: O, k1: K1): O[K1]
  <O extends object, K1 extends keyof O, K2 extends keyof O[K1]>(
    o: O,
    k1: K1,
    k2: K2
  ): O[K1][K2]
  <
    O extends object,
    K1 extends keyof O,
    K2 extends keyof O[K1],
    K3 extends keyof O[K1][K2]
  >(
    o: O,
    k1: K1,
    k2: K2,
    k3: K3
  ): O[K1][K2][K3]
}

type Weekday = "Mon" | "Tue" | "Wed" | "Thu" | "Fri"
type Day = Weekday | "Sat" | "Sun"

const nextDay: Record<Weekday, Day> = {
  Sat: "Tue",
}

interface PageInfo {
  title: string
}

type Page = "home" | "about" | "contact"

const nav: Record<Page, PageInfo> = {
  about: { title: "about" },
  contact: { title: "contact" },
  home: { title: "home" },
}

nav.about

type Weekday = "Mon" | "Tue" | "Wed" | "Thu" | "Fri"
type Day = Weekday | "Sat" | "Sun"

let nextDay: { [K in Weekday]: Day } = {
  Mon: "Tue",
} /*
	Tue, Wed, Thu, Fri를 포함하지 않음
*/

type OptionsFlags<Type> = {
  [Property in keyof Type]: boolean
}

type FeatureFlags = {
  darkMode: () => void
  newUserProfile: () => void
}

type FeatureOptions1 = OptionsFlags<FeatureFlags>

type FeatureOptions2 = {
  darkMode: boolean
  newUserProfile: boolean
}

type Record<K extends keyof any, T> = {
  [P in K]: T
}

type Account = {
  id: number
  isEmployee: boolean
  notes: string[]
}

type OptionalAccount = {
  [K in keyof Account]?: Account[K]
}

type OptionalAccount2 = {
  [K in keyof Account]: Account[K] | null
}

type OptionalAccount3 = {
  readonly [K in keyof Account]: Account[K]
}

type Account2 = {
  -readonly [K in keyof OptionalAccount3]: Account[K]
}

type Account3 = {
  [K in keyof OptionalAccount]-?: Account[K]
}