type PartialedFoo = Partial<Foo>;

type RequiredFoo = Required<Foo>

type PickedFoo = Pick<Foo, "name">

type OmittedFoo = Omit<Foo, "age">

// as const
const user = { name: "kenji", age: 98} as const

// 型注釈
const user: {name: "kenji", age: 98} = { name: "kenji", age: 98}

type PartMethodName = keyof Pick<Part, "add">

interface Part {
  name: string,
  age: number,
  add(): number
}

type FunctionPropertyNames<T> = {
  [K in keyof T]: T[K] extends Function ? K : never
}[keyof T]

type result = FunctionPropertyNames<Part>

type FunctionPropertyNames<T> = {

type result = FunctionPropertyNames<Part>

[K in keyof T]

let obj: {
  [K: string]: number;
};

T[K] extends Function ? K : never

}[keyof T]

interface Part {
  name: string,
  age: number,
  add(): number
}

type FunctionPropertyNames<T> = {
  [K in keyof T]: T[K]
}

type result = FunctionPropertyNames<Part>

type result = {
    name: string;
    age: number;
    add: () => number;
}

type FunctionPropertyNames<T> = {
  [K in keyof T]: T[K] extends Function ? K : never
}

type Freeze<T> = Readonly<{
  [P in keyof T]: T[P] extends object ? Freeze<T[P]> : T[P];
}>;

type GetFunctionName<T> = {
  [K in keyof T]: T[K] extends Function ? K : never;
}

type NameOfFunction = GetFunctionName<Part>;

type NameOfFunction = {
    name: never;
    age: never;
    add: "add";
}

type GetFunctionName<T> = {
  [K in keyof T]: T[K] extends Function ? K : never;
}[keyof T]

function foo(x: string | number): boolean {
  if (typeof x === "string") {
    return true;
  } else if (typeof x === "number") {
    return false;
  }
  return fail("Unexhaustive!"); //ここはreturnされないので neverが返っている。boolean型が返る関数なのでError
}

function fail(message: string): never { throw new Error(message); } // 常にthrowされるのでnever型が返る

function forever(): never {
  while (true) {
   // 処理
  }  
}

function throwError(): never {
  throw new Error();
}

// 関数ならなんでもOK

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

type ResolvedType<T> =
T extends Promise<infer R> ? R :
T extends Observable<infer R> ? R :
T;

type PropNullable<T> = {[P in keyof T]: T[P] | null};

// 例
interface User { name: string, age: number, money: null }
const obj:PropNullable<User> = { name: "kenji", age: 99, money: null }

const createObj = (obj: { [key: string]: any }): { [key: string]: string } => {
  let o: { [key: string]: string } = {};
  for (const key in obj) {
    o[key] = String(obj[key]);
  }
  return o;
};

let createObj = <T extends unknown>(obj:T) => {
 let o = {} as {[P in keyof T]: string}
 for(const key in obj){
     o[key] = String(obj[key]);
 }
 return o;
}
const anotherFun = createObj;

let createObj = <T, >(obj:T) => {
 let o = {} as {[P in keyof T]: string}
 for(const key in obj){
   o[key] = String(obj[key]);
 }
 return o;
}

let arr = <T extends any[]>(...args: T) {
  return args
}

arr(["a", 1]);

// 例
let letSample = "sample" // string型
const constSample = "sample" // "sample"という文字列リテラル型 

// 型推論によってリテラル型を変数に代入した際にプリミティブ型に拡張されること
// 例えば、

let a = "a" //string

// constでは再代入はできないので`a`型というリテラル型になるが、letは再代入可能なので推論は拡張されプリミティブ型になる

let a: "a" = "a" //"a"

// このように型注釈をつけることでa型というリテラル型になる(型注釈はwideningより優先される)

0 | "hoge"

const num: 0 | "hoge"

function exampleFunction(): string | undefined {
    if (Math.random() > 0.5) {
        return "success";
    }
    // ここでreturnせずに関数が終了する可能性がある
}

function exampleFunction(): void {
    console.log("戻り値なし！");
    // return文がない
}

let objS = ["apple", "orange"];

console.log(objS); // (2) ['apple', 'orange']
foo(objS);
console.log(objS); // (3) ['apple', 'orange', 'abcde']

let objS2 = [1, 2];
console.log(objS2); // (2) [1, 2]
foo(objS2);
console.log(objS2); // (2) [1, 2]

function isDuck(animal: Animal): animal is Duck {
  return animal instanceof Duck;
}

(_: number) => { 
  return "return";
}

(_num: number) => { // ok, _ pre
  return "return";
}

function eachItem(val: number | string, i: number ) {
    if (typeof val === "number") {
        return val.toExponential(3);
    }
    return "";
}
const arr = [4, "fafa", 6];
arr.map(eachItem);

const test = 123;
console.log(test.toExponential(3)); // 1.230e+2

interface Fun {
    (e:number): number
}

function fa(callback: Fun, e: number){
  return callback(e);
}

const fun: Fun = (e) => 1 * e;
const v = fa(fun, 1);

type FunType = (e: number) => number;

function fa(callback: FunType, e: number){
  return callback(e);
}

const fun: FunType = (e) => 1 * e;
const v = fa(fun, 1);

interface Fun {(e: number): number;}

function fa(callback:Fun, e: number){
  return callback(e);
}
const fun:Fun = (e) => 1 * e;
const v = fa(fun, 1);

type FunctionPropertyNames<T> = {
  [K in keyof T]: T[K] extends Function ? K : never
}[keyof T]

{
    [K in keyof T]: T[K] extends YukarinoChi ? K : never
}[keyof T]

// "tokyo"リテラル型を値としてもつプロパティだけを抜き出した型を定義しています

type YukariNoChi = "tokyo"

const obj = {
    name: "kenji",
    age: 99,
    born: "tokyo",
    live: "tokyo"
}
type Obj = {
    name: string,
    age: number,
    born: YukariNoChi,
    live: YukariNoChi
}

const obj2 = {
    born: "tokyo",
    live: "tokyo"
} as const

type OnlySpecificProperty<T> = Pick<T, {[K in keyof T]: T[K] extends YukariNoChi ? K : never}[keyof T]>;


function fun(onlyYukari: OnlySpecificProperty<Obj>){
    return onlyYukari
}
const result = fun(obj2); // Pick<Obj, "born | live">

type YukariNoChi = "tokyo"

const obj = {
    name: "kenji",
    age: 99,
    born: "tokyo" as YukariNoChi,
    live: "tokyo" as YukariNoChi,
}
type Obj = {
    name: string,
    age: number,
    born: YukariNoChi,
    live: YukariNoChi
}

const obj2 = {
    born: "tokyo" as YukariNoChi,
    live: "tokyo" as YukariNoChi,
} 

type OnlySpecificProperty<T> = Pick<T, {[K in keyof T]: T[K] extends YukariNoChi ? K : never}[keyof T]>;


function fun(onlyYukari: OnlySpecificProperty<Obj>){
    return onlyYukari
}
console.log(fun(obj)); // {name: 'kenji', age: 99, born: 'tokyo', live: 'tokyo'}
console.log(fun(obj2));// {born: 'tokyo', live: 'tokyo'}

const array: string | null [] = [];

let arr: (string | null)[] = []

type F = {
    foo: string;
    bar: number;
}
const E:F = { foo: "fafa", bar: "fafa" as unknown as number}

type F = {
    foo: string;
    bar: number;
}

const E:Record<keyof F, string> = { foo: "fafa", bar: "fafa"}

type Sample =  Exclude<string | number | boolean,  boolean> 
// type Sample = string | number

ExcludeはTがUに代入可能ならnever、そうでない場合Tを返すconditionalTypeです

use case
type Q = Exclude<string | number, boolean | string | number>
//boolean

type Q = Exclude<string | number | undefined, any>
// never

// use case
type Q = Exclude<string | number, boolean | string | number>
// type Q = never

type Q2 = Exclude<string | number | undefined, any>
// type Q2 = never

type Sample =  Exclude<string | number | boolean,  any>
// type Sample = never

export default function person({ detail = {} } : Person) {
  return <div>{detail.name}</div>
};

interface Person {
    id: number
    detail?: Detail
}

person({detail: {name: "fafa"}, id: 1 });

person({detail: undefined, id: 2 });

person({id: 3 });

export defaut function person({ detail = {} as Detail} : Person) {
  return <div>{detail.name}</div>
};

interface State {
 name: string
 age?: number
}

function a(o: ServiceUser | User | AppUser): string{
  if ("serviceID" in o) return o.serviceID
  if ("id" in o) return o.id
  return o.appID // AppUser

}

console.log(a(user)) // 1
console.log(a(appUser)) // appId
console.log(a(serviceUser)) // serviceID

function a(o: ServiceUser | User | AppUser){
  if("serviceID" in o) return o.serviceID;
  if("appID" in o) return o.appID;
  return o.id;
}

const result = a(serviceUser) // string

function isService(o: any): o is ServiceUser {
    return o.serviceID === "serviceID"
}

function isAppUser(o: any): o is AppUser {
    return o.appID === "appId"
}

function isUser(o: any): o is User {
    return o.id === "1"
}

function a(o: ServiceUser | User | AppUser){
  if (isService(o)) return o.serviceID;
  if (isAppUser(o))  return o.appID;
  return o.id;
}

const o = { name: "hoge" }
function a(obj: any = o){
    return obj
}

console.log(a({name: "foo"}));　// {name: 'foo'}
console.log(a()); // {name: 'hoge'}

const getDefaultProps = () => {
    return {name: "hoge"}
}
const defaultProps = getDefaultProps();
const o = {name: "hoge"}
function a(o = defaultProps){
    return o
}

a(o)
a();

const a = (b:NotHumman) => {
    if ("run" in b) b.run
}

type NotHumman = Animal | Bird

const b = (b: NotHumman) => {
    if ("run" in b) { // animalであることが確定する
        b.run
    } else {
        b.fly
    }
}

declare function beforeAll(action: (done: DoneFn) => void, timeout?: number): void;

/* WRONG */
declare function beforeAll(action: () => void, timeout?: number): void;
declare function beforeAll(action: (done: DoneFn) => void, timeout?: number): void;

/* OK */
declare function beforeAll(action: (done: DoneFn) => void, timeout?: number): void;

declare function fn(x: HTMLDivElement): string;
declare function fn(x: HTMLElement): number;
declare function fn(x: any): any;

var myElem: HTMLDivElement;
var x = fn(myElem!); // x: any, wat?

declare function fn(x: HTMLDivElement): string;
declare function fn(x: HTMLElement): number;
declare function fn(x: any): any;

var myElem: HTMLDivElement;
var x = fn(myElem); // x: string, :)

interface Example {
  diff(one: string, two?: string, three?: boolean): number;
}

y = x; // ok!
x = y; // error

// example
type F = (name: string, n: number) => void;
let f: F = (value: string) => {
  //実装は使わないでもokだが
  console.log("here");
};
f("how", 2); //渡す際に満たさないといけない,

let x = (a: number) => 0;
let y = (b: string, s: string) => 0;

// 1
y = x;

let x = () => ({ name: "Alice" });
let y = () => ({ name: "Alice", location: "Seattle" });

x = y; // OK
y = x; // エラー。xの戻り値には location プロパティがない

type StrFunc = (arg: string) => string;
type NumFunc = (arg: number) => string;
type StrOrNumFunc = <T>(arg: T) => string

declare const obj: StrOrNumFunc
obj("fa");

// or

(obj as StrFunc)("fa"); // unnn...

let obj: MyObj = {
  name: "kenji",
  age: undefined
};

interface MyObj {
  name: string;
  age?: number | undefined;
}

// lib.d.ts
declare var console: Console;

interface Foo {
  name: string;
  age: number;
}

// オブジェクトリテラル型はFooが知っているプロパティのみ代入可能です。ageは知りません。
// これを回避するためにはオブジェクト型にすることです。

interface Foo {
  name: string;
}
const other = { name: "kenji", age: 90 };
// otherで推論が下記のように変わる
const other: {
  name: string;
  age: number;
}
let obj: Foo = other;

// or

//何が入ってくるかわからない場合
interface Foo {
  name: string;
  [other: string]: any; //here
}

let obj: Foo = { name: "kenji", age: 90 };

interface fooInterface {
    [index:string] : {message: string}
}

let foo: fooInterface = {}
foo["a"] = { message: "some message"};

foo = {
    b: {message: 2} // error
}

let foo:{ [index: string]: { message: string }} = {}
foo["a"] = { message: "some message"};

const tupleStrNum = ["X", 2] as [string, number];

const tupleStrNum = ["x", 2] as [string, number];
//const tupleStrNum: [string, number] = ["X", 2];

interface SomeObject {
    firstKey:   string;
    secondKey:  string;
    thirdKey:   { id: { name: string} }
}