npm install -D typescript
npx tsc --init
npx tsc index.ts

let isDone: boolean = false;
let age: number = 42;
let name: string = "Ada";
let big: bigint = 100n;
let sym: symbol = Symbol("id");
let nothing: null = null;
let notDefined: undefined = undefined;

let a: any = 10;
a.foo.bar; // ✅ compiles, 💥 crashes at runtime

let u: unknown = 10;
u.toFixed(); // ❌ Object is of type 'unknown'
if (typeof u === "number") {
  u.toFixed(); // ✅ narrowed to number
}

function fail(msg: string): never {
  throw new Error(msg);
}

let nums: number[] = [1, 2, 3];
let strs: Array<string> = ["a", "b"];

// Tuple: fixed length, fixed types per position
let pair: [string, number] = ["age", 30];

// Named tuple members (readability)
let point: [x: number, y: number] = [10, 20];

// Optional and rest elements in tuples
let flexible: [string, number?, ...boolean[]] = ["ok"];

const nums: readonly number[] = [1, 2, 3];
// nums.push(4); // ❌ Property 'push' does not exist on type 'readonly number[]'

const tuple: readonly [string, number] = ["age", 30];
// tuple[0] = "height"; // ❌ Cannot assign to '0' because it is a read-only property

let user: { name: string; age: number } = { name: "Ada", age: 36 };

let direction: "up" | "down" | "left" | "right";
direction = "up";     // ✅
direction = "north";  // ❌ not assignable

const status = "active" as const; // literal type "active", not string

interface Profile { address?: { city?: string } }

function getCity(p: Profile): string {
  // Optional chaining: short-circuits to undefined if any link is nullish
  const city = p.address?.city;

  // Nullish coalescing: only falls back on null/undefined (not "" or 0)
  return city ?? "Unknown city";
}

// Optional call
function run(cb?: () => void) {
  cb?.();
}

function getElement(id: string): HTMLElement {
  // document.getElementById can return null; ! asserts it won't here
  return document.getElementById(id)!;
}

let count = 5;        // inferred: number
let items = [1, 2, 3]; // inferred: number[]
const config = { retries: 3, url: "/api" }; // inferred object shape

window.onmousedown = function (event) {
  console.log(event.button); // 'event' inferred as MouseEvent
};

let mixed = [1, "two", 3]; // inferred: (string | number)[]

let a = "hello";        // widened to string
const b = "hello";      // literal type "hello"

let obj = { kind: "circle" }; // obj.kind widened to string
const obj2 = { kind: "circle" } as const; // obj2.kind is "circle"

declare function pair<T>(a: T, b: T): T[];
const p = pair(1, "two"); // T inferred as string | number in some contexts, or an error under strict inference

// Inference from generic return position
function wrap<T>(value: T) { return { value }; }
const wrapped = wrap(42); // { value: number }

function add(a: number, b: number): number {
  return a + b;
}

const multiply = (a: number, b: number): number => a * b;

// Function type expression
let operation: (a: number, b: number) => number;
operation = add;

function greet(name: string, greeting?: string): string {
  return `${greeting ?? "Hello"}, ${name}!`;
}

function power(base: number, exponent: number = 2): number {
  return base ** exponent;
}

function sum(...nums: number[]): number {
  return nums.reduce((a, b) => a + b, 0);
}

function makeDate(timestamp: number): Date;
function makeDate(month: number, day: number, year: number): Date;
function makeDate(monthOrTs: number, day?: number, year?: number): Date {
  if (day !== undefined && year !== undefined) {
    return new Date(year, monthOrTs, day);
  }
  return new Date(monthOrTs);
}

interface Button {
  label: string;
  onClick(this: Button, event: Event): void;
}

function* range(start: number, end: number): Generator<number> {
  for (let i = start; i < end; i++) yield i;
}

for (const n of range(1, 4)) {
  console.log(n); // n: number
}

class Playlist implements Iterable<string> {
  private tracks: string[] = ["a", "b", "c"];
  [Symbol.iterator](): Iterator<string> {
    return this.tracks[Symbol.iterator]();
  }
}

interface User {
  readonly id: number;
  name: string;
  email?: string; // optional property
}

const u: User = { id: 1, name: "Grace" };

type Point = { x: number; y: number };
type ID = string | number;
type Callback = (data: string) => void;

interface Animal { name: string; }
interface Dog extends Animal { breed: string; }

const rex: Dog = { name: "Rex", breed: "Labrador" };

interface StringMap {
  [key: string]: string;
}

const dict: StringMap = { hello: "world" };

class Person {
  name: string;
  private age: number;
  protected ssn?: string;
  readonly id: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
    this.id = Math.random();
  }

  greet(): string {
    return `Hi, I'm ${this.name}`;
  }
}

class Point {
  constructor(public x: number, public y: number) {}
}
// Equivalent to declaring 'x' and 'y' fields and assigning them manually

abstract class Shape {
  abstract area(): number;
  describe(): string {
    return `Area: ${this.area()}`;
  }
}

class Circle extends Shape {
  constructor(private radius: number) { super(); }
  area(): number { return Math.PI * this.radius ** 2; }
}

interface Flyable { fly(): void; }

class Bird implements Flyable {
  fly() { console.log("Flap flap!"); }
}

class Counter {
  static count = 0;
  static increment() { Counter.count++; }
}

class Temperature {
  private _celsius = 0;
  get fahrenheit(): number { return this._celsius * 9 / 5 + 32; }
  set fahrenheit(f: number) { this._celsius = (f - 32) * 5 / 9; }
}

type Constructor<T = {}> = new (...args: any[]) => T;

function Timestamped<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    timestamp = Date.now();
  };
}

class Note { constructor(public text: string) {} }
const TimestampedNote = Timestamped(Note);
const n = new TimestampedNote("hello"); // has both .text and .timestamp

enum Direction {
  Up,    // 0
  Down,  // 1
  Left,  // 2
  Right, // 3
}

enum Status {
  Active = "ACTIVE",
  Inactive = "INACTIVE",
}

const enum Level { Low, Medium, High }
let l = Level.Medium; // compiles to: let l = 1;

function printId(id: string | number) {
  console.log(id);
}

type Named = { name: string };
type Aged = { age: number };
type Person = Named & Aged; // must satisfy BOTH shapes

function isString(val: unknown): val is string {
  return typeof val === "string";
}

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

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

function assertNever(x: never): never {
  throw new Error("Unexpected object: " + x);
}

class Cat { meow() {} }
class Dog { bark() {} }

function isCat(pet: Cat | Dog): pet is Cat {
  return pet instanceof Cat;
}

// Combining guards with generics
function isNotNull<T>(value: T | null): value is T {
  return value !== null;
}
const nums = [1, null, 2, null, 3].filter(isNotNull); // number[]

function assertIsNumber(val: unknown): asserts val is number {
  if (typeof val !== "number") throw new Error("Not a number!");
}

function assert(condition: unknown, message: string): asserts condition {
  if (!condition) throw new Error(message);
}

function assertIsDefined<T>(val: T): asserts val is NonNullable<T> {
  if (val === undefined || val === null) {
    throw new Error("Expected value to be defined");
  }
}

function process(input?: string) {
  assertIsDefined(input);
  input.trim(); // input narrowed to string
}

function identity<T>(arg: T): T {
  return arg;
}

const first = <T,>(arr: T[]): T => arr[0];

interface Box<T> {
  value: T;
}

class Stack<T> {
  private items: T[] = [];
  push(item: T) { this.items.push(item); }
  pop(): T | undefined { return this.items.pop(); }
}

interface HasLength { length: number; }

function logLength<T extends HasLength>(item: T): T {
  console.log(item.length);
  return item;
}

interface ApiResponse<T = unknown> {
  data: T;
  error?: string;
}

function getProp<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

// Conditional generic constraint chaining
type ApiResult<T> = T extends { error: infer E } ? { ok: false; error: E } : { ok: true; data: T };

// Generic builder pattern
class QueryBuilder<T extends Record<string, unknown> = {}> {
  private filters: T = {} as T;
  where<K extends string, V>(key: K, value: V): QueryBuilder<T & Record<K, V>> {
    return new QueryBuilder<T & Record<K, V>>();
  }
}

interface Constructable<T> { new (...args: any[]): T; }

function createInstance<T>(ctor: Constructable<T>, ...args: any[]): T {
  return new ctor(...args);
}

class Widget { constructor(public label: string) {} }
const w = createInstance(Widget, "Save Button");

type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;
type Deep = Flatten<number[][][]>; // number

// Recursive builder chaining
class Chain<T extends any[] = []> {
  add<U>(_: U): Chain<[...T, U]> { return new Chain(); }
  build(): T { return [] as unknown as T; }
}

type Readonly2<T> = { readonly [K in keyof T]: T[K] };
type Partial2<T> = { [K in keyof T]?: T[K] };
type Nullable<T> = { [K in keyof T]: T[K] | null };

type IsString<T> = T extends string ? true : false;
type A = IsString<"hi">; // true
type B = IsString<42>;   // false

// Distributive over unions
type ToArray<T> = T extends any ? T[] : never;
type Result = ToArray<string | number>; // string[] | number[]

type ReturnTypeOf<T> = T extends (...args: any[]) => infer R ? R : never;
type Result = ReturnTypeOf<() => string>; // string

type ElementType<T> = T extends (infer U)[] ? U : T;
type Elem = ElementType<number[]>; // number

type Greeting = `Hello, ${string}!`;
type EventName<T extends string> = `on${Capitalize<T>}`;
type ClickEvent = EventName<"click">; // "onClick"

type JSONValue =
  | string
  | number
  | boolean
  | null
  | JSONValue[]
  | { [key: string]: JSONValue };

// Nested conditional chains ("type-level switch")
type TypeName<T> =
  T extends string ? "string" :
  T extends number ? "number" :
  T extends boolean ? "boolean" :
  T extends undefined ? "undefined" :
  T extends Function ? "function" :
  "object";

// Conditional type with multiple infer sites
type Swap<T> = T extends [infer A, infer B] ? [B, A] : T;
type S = Swap<[string, number]>; // [number, string]

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

interface Person { name: string; age: number; }
type PersonGetters = Getters<Person>;
// { getName: () => string; getAge: () => number }

// Filter out keys via 'never'
type OmitByType<T, U> = {
  [K in keyof T as T[K] extends U ? never : K]: T[K];
};

type Route = `/${string}`;
type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
type Endpoint = `${HttpMethod} ${Route}`;

// Extracting parts with infer inside a template literal type
type ExtractId<T> = T extends `user-${infer Id}` ? Id : never;
type Id1 = ExtractId<"user-42">; // "42"

// Splitting a string type
type Split<S extends string, D extends string> =
  S extends `${infer Head}${D}${infer Rest}` ? [Head, ...Split<Rest, D>] : [S];
type Parts = Split<"a.b.c", ".">; // ["a", "b", "c"]

type Length<T extends readonly unknown[]> = T["length"];

type BuildTuple<N extends number, T extends unknown[] = []> =
  T["length"] extends N ? T : BuildTuple<N, [...T, unknown]>;

type Add<A extends number, B extends number> =
  [...BuildTuple<A>, ...BuildTuple<B>]["length"];

type Sum = Add<2, 3>; // 5

type Brand<T, B extends string> = T & { readonly __brand: B };

type UserId = Brand<string, "UserId">;
type OrderId = Brand<string, "OrderId">;

function asUserId(id: string): UserId { return id as UserId; }

function getUser(id: UserId) { /* ... */ }
getUser(asUserId("u1"));      // ✅
// getUser("u1");             // ❌ plain string is not a UserId

type Exact<T, Shape> = T extends Shape
  ? Exclude<keyof T, keyof Shape> extends never ? T : never
  : never;

function createUser<T>(user: Exact<T, { name: string; age: number }>) { /* ... */ }

interface Point2D { x: number; y: number; }
interface Point3D { x: number; y: number; z: number; }

function print2D(p: Point2D) { console.log(p.x, p.y); }
const p3: Point3D = { x: 1, y: 2, z: 3 };
print2D(p3); // ✅ Point3D structurally satisfies Point2D

type Animal = { name: string };
type Dog = { name: string; breed: string };

let feed: (a: Animal) => void = (a) => {};
let feedDog: (d: Dog) => void = feed; // ✅ contravariant parameter — allowed

interface Config { url: string; }

const cfg1: Config = { url: "/api", timeout: 5000 }; // ❌ excess property 'timeout'

const draft = { url: "/api", timeout: 5000 };
const cfg2: Config = draft; // ✅ no excess-property check via variable

interface Todo { title: string; description: string; done: boolean; }

type TodoPreview = Pick<Todo, "title" | "done">;
type TodoDraft = Partial<Todo>;
type TodoRecord = Record<string, Todo>;
type WithoutDone = Omit<Todo, "done">;

function fetchTodo(): Promise<Todo> { /* ... */ return null as any; }
type FetchedTodo = Awaited<ReturnType<typeof fetchTodo>>; // Todo

type DeepPartial<T> = T extends object
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;

interface Settings { ui: { theme: string; fontSize: number }; }
type PartialSettings = DeepPartial<Settings>;
// { ui?: { theme?: string; fontSize?: number } }

type DeepReadonly<T> = T extends object
  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
  : T;

const frozen: DeepReadonly<{ a: { b: number } }> = { a: { b: 1 } };
// frozen.a.b = 2; // ❌ readonly at every level

type Mutable<T> = { -readonly [K in keyof T]: T[K] };

interface Frozen { readonly id: number; }
type Unfrozen = Mutable<Frozen>; // { id: number }

type Merge<A, B> = Omit<A, keyof B> & B;

interface Base { id: number; name: string; }
interface Override { name: number; }
type Merged = Merge<Base, Override>; // { id: number; name: number }

type Simplify<T> = { [K in keyof T]: T[K] } & {};

type Messy = { a: string } & { b: number };
type Clean = Simplify<Messy>; // { a: string; b: number }

type UnionToIntersection<U> =
  (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

type Combined = UnionToIntersection<{ a: string } | { b: number }>;
// { a: string } & { b: number }

type ValueOf<T> = T[keyof T];

interface StatusMap { active: "ACTIVE"; inactive: "INACTIVE"; }
type StatusValue = ValueOf<StatusMap>; // "ACTIVE" | "INACTIVE"

// math.ts
export function add(a: number, b: number) { return a + b; }
export default class Calculator {}

// main.ts
import Calculator, { add } from "./math";
import * as MathUtils from "./math";

import type { User } from "./types";
export type { User };

namespace Validation {
  export interface StringValidator {
    isValid(s: string): boolean;
  }
}

namespace Shapes {
  export class Circle {}
}
namespace Shapes {
  export class Square {}
}
// Shapes now exposes both Circle and Square
const c = new Shapes.Circle();

declare module "my-untyped-lib" {
  export function doSomething(input: string): number;
}

declare global {
  interface Window {
    analytics: { track(event: string): void };
  }
}

npm install -D @types/lodash @types/node

declare module "*.svg" {
  const content: string;
  export default content;
}

declare module "*.module.css" {
  const classes: { readonly [key: string]: string };
  export default classes;
}

interface Window {
  myGlobal: string;
}
interface Window {
  anotherGlobal: number;
}
// Window now has both properties merged

// namespace + class merging
class Album {
  label: Album.AlbumLabel = { name: "Unknown" };
}
namespace Album {
  export interface AlbumLabel { name: string; }
}

// namespace + function merging
function buildLabel(name: string): string {
  return buildLabel.prefix + name;
}
namespace buildLabel {
  export let prefix = "Label: ";
}

import "express";

declare module "express" {
  interface Request {
    user?: { id: string; role: string };
  }
}

function fetchUser(id: number): Promise<{ id: number; name: string }> {
  return fetch(`/users/${id}`).then(res => res.json());
}

async function loadUser(id: number) {
  try {
    const res = await fetch(`/users/${id}`);
    if (!res.ok) throw new Error("Request failed");
    const user: { id: number; name: string } = await res.json();
    return user;
  } catch (err) {
    console.error(err);
    throw err;
  }
}

const results: [number, string] = await Promise.all([
  Promise.resolve(1),
  Promise.resolve("two"),
]);

// Typed retry helper
async function retry<T>(fn: () => Promise<T>, attempts = 3): Promise<T> {
  try {
    return await fn();
  } catch (err) {
    if (attempts <= 1) throw err;
    return retry(fn, attempts - 1);
  }
}

// Async generators
async function* paginate<T>(fetchPage: (page: number) => Promise<T[]>) {
  let page = 0;
  while (true) {
    const items = await fetchPage(page++);
    if (items.length === 0) return;
    yield items;
  }
}

class ValidationError extends Error {
  constructor(message: string, public field: string) {
    super(message);
    this.name = "ValidationError";
  }
}

function validate(age: number) {
  if (age < 0) throw new ValidationError("Age cannot be negative", "age");
}

abstract class AppError extends Error {
  abstract readonly code: string;
}

class NotFoundError extends AppError {
  readonly code = "NOT_FOUND";
  constructor(public resource: string) { super(`${resource} not found`); }
}

class ValidationAppError extends AppError {
  readonly code = "VALIDATION_ERROR";
  constructor(public fields: string[]) { super("Validation failed"); }
}

function handle(err: AppError) {
  switch (err.code) {
    case "NOT_FOUND": return 404;
    case "VALIDATION_ERROR": return 400;
    default: return 500;
  }
}

function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const original = descriptor.value;
  descriptor.value = function (...args: any[]) {
    console.log(`Calling ${propertyKey}`);
    return original.apply(this, args);
  };
}

class Service {
  @log
  fetchData() { /* ... */ }
}

function logged(target: Function, context: ClassMethodDecoratorContext) {
  const name = String(context.name);
  return function (this: any, ...args: any[]) {
    console.log(`Entering ${name}`);
    return target.apply(this, args);
  };
}

class Greeter {
  @logged
  greet(name: string) { return `Hello, ${name}`; }
}

type Colors = "red" | "green" | "blue";

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

// palette.red is still known as number[], not string | number[]
palette.red.push(10);

function tuplify<const T extends readonly unknown[]>(...args: T): T {
  return args;
}

const t1 = tuplify(1, 2, 3);       // readonly [1, 2, 3]
const t2 = tuplify("a", "b");      // readonly ["a", "b"]

class FileHandle {
  constructor(private path: string) { console.log("open", path); }
  [Symbol.dispose]() { console.log("close", this.path); }
}

function readConfig() {
  using file = new FileHandle("config.json");
  // ... use file ...
} // file[Symbol.dispose]() is called here automatically