Blowing in the wind

// escape hatch(assert the type)
function formatInput(input: string) {
  console.log(input)
}

function getUserInput(): number | string {
  return 123;
}
let input = getUserInput();
formatInput(input as string);

// distributive conditional type
type WithOut<T, U> = T extends U ? never : T;
//type WithOut<T, U> = T | U
type A = WithOut<boolean | number="" | string="", boolean="">; // type of A : number/string

let a: A = "sd";
a = 123;
//a = false   // error

// user defined type guard
function isString(a: unknown): a is string {
  // if a is not defined, parseInput isString cause error
  return typeof a === "string";
}

function parseInput(input: string | number) {
  let formatedInput: string;
  if (isString(input)) {
    formatedInput = input.toUpperCase();
    console.log(formatedInput)
  }
}

parseInput('qwerty')

// TypeScript deep dive sample
interface Foo {
  foo: number;
  common: string;
}

interface Bar {
  bar: number;
  common: string;
}

function isFoo(arg: any): arg is Foo {
  return arg.foo !== undefined;
}

function doStuff(arg: Foo | Bar) {
  if (isFoo(arg)) {
    console.log(arg.foo);
    //console.log(arg.bar)  // VScode detects as an error
    console.log(arg.common);
  } else {
    //console.log(arg.foo)  // error
    console.log(arg.bar);
    console.log(arg.common);
  }
}

doStuff({ foo: 234, common: "abc" });
doStuff({ bar: 567, common: "efg" });

QWERTY
234
abc
567
efg

type Unit = "EUR" | "GBP" | "JPY" | "USD";

export type Currency = {
  unit: Unit;
  value: number;
};

export let Currency = {
  from(value: number, unit: Unit): Currency {
    return {
      unit: unit,
      value,
    };
  },
};

// companion object pattern
import { Currency } from "./Currency"; // works like a class

let amountDue: Currency = {   // set object directly as a 'type'
  unit: "JPY",
  value: 12000,
};

let otherAmountDue = Currency.from(85, "EUR"); // use 'from' function as a 'value'

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

// record type(to use above types)
let nextDay: Record<WeekDay, Day> = {
  Mon: "Tue",
  Tue: "Wed",
  Wed: "Thu",
  Thu: "Fri",
  Fri: "Sat",
};

console.log(nextDay.Wed);   //Thu

// mapped type
let nextDayM: { [k in WeekDay]: Day } = {
  Mon: "Tue",
  Tue: "Wed",
  Wed: "Thu",
  Thu: "Fri",
  Fri: "Sat",
};

console.log(nextDayM.Mon);  //Tue

// keyof operator
type ActiveLog = {
  lastEvent: Date;
  events: {
    id: string;
    timestamp: Date;
    type: "Read" | "Write";
  };
};

let activeLog: ActiveLog = {
  lastEvent: new Date(),
  events: {
    id: "active",
    timestamp: new Date(),
    type: "Read",
  },
};

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

let get: Get = (object: any, ...keys: string[]) => {
  let result = object;
  keys.forEach((k) => (result = result[k]));
  return result;
};

console.log(get(activeLog, "events", "timestamp"));

2023-07-07T04:40:22.301Z