interface Dog { name: string; }
interface Person { name: string; }

let myDog: Dog = { name: "바둑이" };
let myPerson: Person = myDog; // ✅ TypeScript 에서는 통과

interface Pointlike {
	x: number;
	y: number;
}

interface Named {
	name: string;
}

// 같은 속성을 가지고 있어서 자연스럽게 interface 를 따르는 것처럼 사용 가능
const obj = {
	x: 0,
	y: 0,
	name: "Origin",
};

function logPoint(point: Pointlike) {
	console.log("x = " + point.x + ", y = " + point.y);
}

function logName(x: Named) {
	console.log("Hello, " + x.name);
}

logPoint(obj);
logName(obj);

// Accessing the property 'toLowerCase'
// on 'message' and then calling it
message.toLowerCase();

// Calling 'message'
message();

const message = "Hello World!";

function fn(x) {
	return x.flip();
}

const user = {
	name: "Daniel",
	age: 26,
};

user.location;
// Property 'location' does not exist on type '{ name: string; age: number; }'.

// This is an industrial-grade general-purpose greeter function:

function greet(person, date) {
	console.log(`Hello ${person}, today is ${date}!`);
}

greet("Brendan");

let obj: any = { x: 0 };
// None of the following lines of code will throw compiler errors.
// Using `any` disables all further type checking, and it is assumed
// you know the environment better than TypeScript.
obj.foo();
obj();
obj.bar = 100;
obj = "hello";
const n: number = obj;

let myName: string = "Alice";

// Parameter type annotation. 붙은 경우 type-checking 함
function greet(name: string) {}

// Return type annotation
// TS 가 자동으로 함수의 리턴 타입을 추론하기 때문에 필요하지는 않음
function getFavoriteNumber(): number {
	return 26;
}

// Promise 를 return하는 경우
async function getFavoriteNumber(): Promise<number> {
	return 26;
}

// Anonymous function
const names = ["Alice", "Bob", "Eve"];

// Contextual typing for function - parameter s inferred to have type string
names.forEach(function (s) {
	console.log(s.toUpperCase());
});

// parameter s 가 type annotation 이 없어도 `forEach` 함수의 type 을 사용해서 항상 `s` 가 갖는 타입을 알 수 있음 : contextual typing (함수가 등장한 context 가 type 을 알려줌)

// Contextual typing also applies to arrow functions
names.forEach((s) => {
	console.log(s.toUpperCase());
});

// The parameter's type annotation is an object type
function printCoord(pt: { x: number; y: number }) {
	console.log("The coordinate's x value is " + pt.x);
	console.log("The coordinate's y value is " + pt.y);
}

printCoord({ x: 3, y: 7 }); // , 나 ; 를 사용해서 property 구분 가능

// Optional Property
function printName(obj: { first: string; last?: string }) {
	// ...
}

// Both OK
printName({ first: "Bob" });
printName({ first: "Alice", last: "Alisson" });

// optional property 에 대한 undefined 검사
function printName(obj: { first: string; last?: string }) {
// Error - might crash if 'obj.last' wasn't provided!
console.log(obj.last.toUpperCase());
// 'obj.last' is possibly 'undefined'.

if (obj.last !== undefined) {
// OK
	console.log(obj.last.toUpperCase());
}

// A safe alternative using modern JavaScript syntax:
console.log(obj.last?.toUpperCase());
}

// Union type
function printId(id: number | string) {
	console.log("Your ID is: " + id);
}

// OK
printId(101);

// OK
printId("202");

// Error
printId({ myID: 22342 });

Argument of type '{ myID: number; }' is not assignable to parameter of type 'string | number'.

// separator 를 첫 번째 요소 전에 쓸 수도 있음
function printTextOrNumberOrBool(
	textOrNumberOrBool:
	| string
	| number
	| boolean
) {
	console.log(textOrNumberOrBool);
}

function printId(id: number | string) {
	if (typeof id === "string") {
		// In this branch, id is of type 'string'
		console.log(id.toUpperCase());
	} else {
		// Here, id is of type 'number'
		console.log(id);
	}
}

function welcomePeople(x: string[] | string) {
if (Array.isArray(x)) {
		// Here: 'x' is 'string[]'
		console.log("Hello, " + x.join(" and "));
	} else {
		// Here: 'x' is 'string'
		console.log("Welcome lone traveler " + x);
	}
}

type Point = {
	x: number;
	y: number;
};

function printCoord(pt: Point) {
	console.log("The coordinate's x value is " + pt.x);
	console.log("The coordinate's y value is " + pt.y);
}

printCoord({ x: 100, y: 100 });

type ID = number | string;

type UserInputSanitizedString = string;

function sanitizeInput(str: string): UserInputSanitizedString {
	return sanitize(str);
}

// Create a sanitized input
let userInput = sanitizeInput(getInput());

// Can still be re-assigned with a string though
// 근본적으로 두 타입이 같기 때문에 가능
userInput = "new input"; 

interface Point {
	x: number;
	y: number;
}

function printCoord(pt: Point) {
	console.log("The coordinate's x value is " + pt.x);
	console.log("The coordinate's y value is " + pt.y);
}

printCoord({ x: 100, y: 100 });

// interface
interface Animal {
  name: string;
}  

interface Bear extends Animal {
  honey: boolean;
} 
 
const bear = getBear();
bear.name;
bear.honey;

// type
type Animal = {
  name: string;
}  

type Bear = Animal & { 
  honey: boolean;
}  

const bear = getBear();
bear.name;
bear.honey;

interface Window {
  title: string;
}  

interface Window {
  ts: TypeScriptAPI;
}  

const src = 'const a = "Hello World"';
window.ts.transpileModule(src, {});

const myCanvas = document.getElementById("main_canvas") as HTMLCanvasElement;

const myCanvas = <HTMLCanvasElement>document.getElementById("main_canvas");

let changingString = "Hello World";
changingString = "Olá Mundo"
// Because `changingString` can represent any possible string, that
// is how TypeScript describes it in the type system

const constantString = "Hello World";
// Because `constantString` can only represent 1 possible string, it
// has a literal type representation
constantString;

let x: "hello" = "hello";
// OK
x = "hello";

// ...
x = "howdy";
// ❌ Type '"howdy"' is not assignable to type '"hello"'.

function printText(s: string, alignment: "left" | "right" | "center") {
	// ...
}

// OK
printText("Hello, world", "left");

printText("G'day, mate", "centre");
// ❌ Argument of type '"centre"' is not assignable to parameter of type '"left" | "right" | "center"'.

function compare(a: string, b: string): -1 | 0 | 1 {
	return a === b ? 0 : a > b ? 1 : -1;
}

interface Options {
	width: number;
}

function configure(x: Options | "auto") {
	// ...
}

// OK
configure({ width: 100 });
configure("auto");

configure("automatic");
// ❌ Argument of type '"automatic"' is not assignable to parameter of type 'Options | "auto"'.

const obj = { counter: 0 };

//    
if (someCondition) {
	obj.counter = 1; // 에러로 취급 안함
}

declare function handleRequest(url: string, method: "GET" | "POST"): void;

const req = { url: "https://example.com", method: "GET" };
handleRequest(req.url, req.method);
// ❌ Argument of type 'string' is not assignable to parameter of type '"GET" | "POST"'.

// 1. type assertion 사용

// literal type "GET" 사용
const req = { url: "https://example.com", method: "GET" as "GET" };
handleRequest(req.url, req.method as "GET")

// 2. as const 를 사용해서 전체 object 를 type literal 로 변환
const req = { url: "https://example.com", method: "GET" } as const;
handleRequest(req.url, req.method);

function liveDangerously(x?: number | null) {
	// No error
	console.log(x!.toFixed());
}

function printAll(strs: string | string[] | null) {
	if (typeof strs === "object") {
		for (const s of strs) {
			// ❌ 'strs' is possibly 'null'.
			console.log(s);
		}
	} else if (typeof strs === "string") {
		console.log(strs);
	} else {
		// do nothing
	}
}

function getUsersOnlineMessage(numUsersOnline: number) {
	if (numUsersOnline) {
		return `There are ${numUsersOnline} online now!`;
	}
	
	return "Nobody's here. :(";
}

function printAll(strs: string | string[] | null) {
	// `strs` 가 null 인 경우도 여기서 걸러짐
	if (strs && typeof strs === "object") {
		for (const s of strs) {
			console.log(s);
		}
	} else if (typeof strs === "string") {
		console.log(strs);
	}
}

function example(x: string | number, y: string | boolean) {
	if (x === y) {
		// x, y 가 같은 경우는 그들의 타입이 같아야지 성립하기 때문에 TS 는 여기서 x, y 가 둘 다 무조건 string인 것을 알게 됨
		x.toUpperCase();
		y.toLowerCase();
	} else {
		console.log(x);
		console.log(y);
	}
}

type Fish = { swim: () => void };
type Bird = { fly: () => void };

function move(animal: Fish | Bird) {
  if ("swim" in animal) {
    // 🔵 "True" 브랜치: 여기가 실행된다는 건 animal에 'swim'이 있다는 뜻!
    // 타입스크립트는 이제 animal을 'Fish' 타입으로 확신하고 처리합니다.
    animal.swim(); 
  } else {
    // 🔴 "False" 브랜치: 'swim'이 없다는 뜻!
    // 남은 가능성은 'Bird'뿐이므로 animal을 'Bird' 타입으로 간주합니다.
    animal.fly();
  }
}

type Human = { name: string; age?: number }; // age가 있을 수도, 없을 수도 있음
type Robot = { serial: number };

function check(subject: Human | Robot) {
  if ("age" in subject) {
    // age가 선택적(optional) 속성이더라도, 
    // 일단 존재한다면 이 녀석은 Robot이 아니라 Human일 확률이 높다고 좁혀줍니다.
    console.log(subject.name); 
  }
}

// interface 는 체크 불가.
function logValue(x: Date | string) {
  if (x instanceof Date) {
    // 이제 x는 Date 객체로 좁혀짐!
    console.log(x.toUTCString());
  } else {
    // x는 자동으로 string이 됨
    console.log(x.toUpperCase());
  }
}

let x = Math.random() < 0.5 ? 10 : "hello world!";
// let x: string | number

x = 1;
console.log(x);
// let x: number

x = "goodbye!";
console.log(x);
// let x: string

x = true;
// ❌ 얘는 안됨

function isFish(pet: Fish | Bird): pet is Fish {
	return (pet as Fish).swim !=== undefined;
}

interface Shape {
	kind: "circle" | "square"; // union of string literal types
	radius?: number;
	sideLength?: number;
}

function handleShape(shape: Shape) {
	// oops!
	if (shape.kind === "rect") {
		// ❌ This comparison appears to be unintentional because the types '"circle" | "square"' and '"rect"' have no overlap.
		// ...
	}
}

function getArea(shape: Shape) {
	return Math.PI * shape.radius ** 2; // non-null assertion ! 를 써서 `shape.radius` 가 정의되었다고 할 수도 있지만 이상적인 방법은 아님
	// ❌ 'shape.radius' is possibly 'undefined'.
}

interface Circle {
	kind: "circle"; // common property
	radius: number;
}

interface Square {
	kind: "square"; // common property
	sideLength: number;
}

type Shape = Circle | Square;

function getArea(shape: Shape) {
	return Math.PI * shape.radius ** 2;
	// ❌ Property 'radius' does not exist on type 'Shape'. Property 'radius' does not exist on type 'Square'.
}

// union 의 모든 type 이 공통된 literal type 이 있는 경우 TS 는 discriminated union 으로 간주해서 union 의 member 를 narrow out 할 수 있음
function getArea(shape: Shape) {
	if (shape.kind === "circle") {
		return Math.PI * shape.radius ** 2;
		// ✅ (parameter) shape: Circle
	}
}

function getArea(shape: Shape) {
	switch (shape.kind) {
		case "circle":
			return Math.PI * shape.radius ** 2;
		case "square":
			return shape.sideLength ** 2;
	}
}

type Shape = Circle | Square;

function getArea(shape: Shape) {
	switch (shape.kind) {
		case "circle":
			return Math.PI * shape.radius ** 2;
		case "square":
			return shape.sideLength ** 2;
		default:
			const _exhaustiveCheck: never = shape;
		return _exhaustiveCheck;
	}
}

interface Triangle {
	kind: "triangle";
	sideLength: number;
}

type Shape = Circle | Square | Triangle;

//위 코드 const _exhaustiveCheck 부분에서 `Triangle` is not assignable to type 'never' 에러가 뜸