TS 고급 타입

function isString(test: any): test is string {
  return typeof test === "string";
}

function example(foo: any) {
  if(isString(foo)){
    // 이 영역에서 foo는 string 타입으로 추론된다.
    console.log(foo.length);
  }
}

type numOrStr = number | string;

// 제네릭에 적용될 타입에 number | string 만 허용
function identity<T extends numOrStr>(p1: T): T {
   return p1;
}

class MyArray<A> {
   // 자식으로 부터 제네릭 타입을 받아와 배열 타입을 적용
   constructor(protected items: A[]) {}
}

class Stack<S> extends MyArray<S> {
   push(item: S) {
      this.items.push(item);
   }
   pop() {
      return this.items.pop();
   }
}

class Queue<Q> extends MyArray<Q> {
   offer(item: any) {
      this.items.push(item);
   }
   poll() {
      return this.items.shift();
   }
}

// T extends U ? X : Y
// T가 U에 할당될 수 있으면 타입은 X가 되고 그렇지 않다면 타입이 Y가 된다

// 제네릭이 string이면 문자열배열, 아니면 넘버배열
type IsStringType<T> = T extends string ? string[] : number[];

type T1 = IsStringType<string>; // type T1 = string[]
type T2 = IsStringType<number>; // type T2 = number[]

// 제네릭 `T`는 `boolean` 타입으로 제한.
interface isDataString<T extends boolean> {

  // 제네릭 T에 true가 들어오면 string 타입으로, false가 들어오면 number 타입으로 data 속성을 타입 지정
   data: T extends true ? string : number;
   isString: T;
}

const str: isDataString<true> = {
   data: '홍길동',
   isString: true,
};

const num: isDataString<false> = {
   data: 9999,
   isString: false,
};

type IsStringType<T> = T extends string ? 'yes' : 'no';

type T1 = IsStringType<string | number>;

// T1 타입은 다음과 같은 과정을 거친다.
1. (string | number) extends string ? 'yes' : 'no'
2. (string extends string ? 'yes' : 'no') | (number extends string ? 'yes' : 'no')
3. 'yes' | 'no'

type T3 = string | number extends string ? 'yes' : 'no';
// 'no'

type T1 = (1 | 3 | 5 | 7) extends number ? 'yes' : 'no'; // naked 타입이 아니라서 분산이 되지 않는다.
type T2<T> = T extends number ? T[] : 'no'; // 제네릭 T는 naked 타입이라 분산이 된다.
type T3<T> = T[] extends number ? 'yes' : T[]; // 제네릭이지만 T[] 와 같이 변형된 타입 파라미터는 naked 타입이 아니라서 분산이 일어나지 않는다.

type T4 = T1; // "yes"
type T5 = T2<(1 | 3 | 5 | 7)>; // 1[] | 3[] | 5[] | 7[]
type T6 = T2<(1 | 3 | 5 | 7)>; // (1 | 3 | 5 | 7)[]

type Never<T> = T extends number ? T : never;

type Types = number | string | object;
type T2 = Never<Types>;

// T2 타입은 다음과 같은 과정을 거친다.
1. (number extends number ? T : never) | (string extends number ? T : never) | (object extends number ? T : never)
2. number | never | never
3. number

// T extends infer U ? X : Y
// T를 통하여 U를 추론하고 U가 추론 가능한 타입이면 참, 아니면 거짓

type MyType<T> = T extends infer R ? R : null;
const a : MyType<number> = 123; // number

type Foo<T> = T extends { a: infer U, b: infer U } ? U : never;

type T10 = Foo<{ a: string, b: string }>;  // string
type T11 = Foo<{ a: string, b: number }>;  // string | number

type Bar<T> = T extends { a: () => infer U, b: () => infer U } ? U : never;

type T20 = Bar<{ a: () => string, b: () => string }>;  // string
type T21 = Bar<{ a: () => string, b: () => number }>;  // string | number

type Bar<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;

type T30 = Bar<{ a: (x: string) => void, b: (x: string) => void }>;  // string
type T31 = Bar<{ a: (x: string) => void, b: (x: number) => void }>;  // string & number

const palette: Record<'red' | 'green' | 'blue', [number, number, number] | string> = {
    red: [255, 0, 0],
    green: "#00ff00",
    blue: [0, 0, 255],
};

const greenNormalized = palette.green.toUpperCase(); // property toUpperCase does not exist on type [number, number, number]

const palette = {
    red: [255, 0, 0],
    green: "#00ff00",
    blue: [0, 0, 255],
} satisfies Record<'red' | 'green' | 'blue', [number, number, number] | string>;

// pallette의 추론된 타입은 다음과 같다.
const palette: {
    red: [number, number, number];
    green: string;
    blue: [number, number, number];
}