TypeScript Advanced Type System

// Type alias - flexible for any type
type StringOrNumber = string | number;
type Coordinate = [number, number];
type UserID = string;

// Interface - best for object shapes
interface Person {
    name: string;
    age: number;
}

interface Employee extends Person {
    employeeId: string;
    department: string;
}

// Declaration merging (interfaces only)
interface Window {
    customProperty: string;
}
interface Window {
    anotherProperty: number;
}
// Window now has both properties

// Type composition
type WithTimestamp = { timestamp: Date };
type TrackedPerson = Person & WithTimestamp;

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

// String enum (preferred)
enum Status {
    Pending = "PENDING",
    Active = "ACTIVE",
    Completed = "COMPLETED"
}

// Custom numeric values
enum HttpStatus {
    OK = 200,
    NotFound = 404,
    ServerError = 500
}

// Const enum (performance optimization)
const enum Colors {
    Red = "#FF0000",
    Green = "#00FF00",
    Blue = "#0000FF"
}

// Usage
let status: Status = Status.Active;
let color = Colors.Red;  // Inlined to "#FF0000" at compile time

// as syntax (preferred)
let input = document.getElementById("input") as HTMLInputElement;
input.value = "Hello";

// Angle bracket syntax (avoid in JSX)
let element = <HTMLElement>document.querySelector(".item");

// Double assertion (escape hatch)
let num = "123" as unknown as number;  // Dangerous!

// Const assertion - deep readonly
let config = {
    host: "localhost",
    port: 3000,
    flags: ["debug", "verbose"]
} as const;
// Type: { readonly host: "localhost"; readonly port: 3000; readonly flags: readonly ["debug", "verbose"] }

// Array as const
let arr = [1, 2, 3] as const;  // Type: readonly [1, 2, 3]

// Non-null assertion
function process(value: string | null) {
    let length = value!.length;  // Assert value is not null
}

function process(value: string | number) {
    // typeof guard
    if (typeof value === "string") {
        console.log(value.toUpperCase());  // string
    } else {
        console.log(value.toFixed(2));     // number
    }
}

// instanceof guard
function handle(x: Date | string) {
    if (x instanceof Date) {
        console.log(x.getFullYear());  // Date
    } else {
        console.log(x.length);         // string
    }
}

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

function move(animal: Fish | Bird) {
    if ("swim" in animal) {
        animal.swim();  // Fish
    } else {
        animal.fly();   // Bird
    }
}

// Truthiness narrowing
function print(text: string | null) {
    if (text) {
        console.log(text.toUpperCase());  // string
    }
}

// Type predicate function
function isString(value: unknown): value is string {
    return typeof value === "string";
}

function process(input: unknown) {
    if (isString(input)) {
        console.log(input.toUpperCase());  // Narrowed to string
    }
}

// Complex type guard
interface Cat { meow: () => void; }
interface Dog { bark: () => void; }

function isCat(animal: Cat | Dog): animal is Cat {
    return (animal as Cat).meow !== undefined;
}

function speak(animal: Cat | Dog) {
    if (isCat(animal)) {
        animal.meow();
    } else {
        animal.bark();
    }
}

// Define discriminated union
type Result<T> =
    | { status: "loading" }
    | { status: "success"; data: T }
    | { status: "error"; error: Error };

function handle<T>(result: Result<T>) {
    switch (result.status) {
        case "loading":
            console.log("Loading...");
            break;
        case "success":
            console.log(result.data);  // Type: T
            break;
        case "error":
            console.log(result.error.message);  // Type: Error
            break;
    }
}

// Shape discriminated union
type Shape =
    | { kind: "circle"; radius: number }
    | { kind: "rectangle"; width: number; height: number }
    | { kind: "triangle"; base: number; height: number };

function area(shape: Shape): number {
    switch (shape.kind) {
        case "circle":
            return Math.PI * shape.radius ** 2;
        case "rectangle":
            return shape.width * shape.height;
        case "triangle":
            return 0.5 * shape.base * shape.height;
    }
}

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

function getArea(shape: Shape): number {
    switch (shape.kind) {
        case "circle": return Math.PI * shape.radius ** 2;
        case "rectangle": return shape.width * shape.height;
        case "triangle": return 0.5 * shape.base * shape.height;
        default: return assertNever(shape);  // Compile error if case missing
    }
}

// Basic mapped type
type Nullable<T> = {
    [K in keyof T]: T[K] | null;
};

type User = { name: string; age: number };
type NullableUser = Nullable<User>;
// Result: { name: string | null; age: number | null }

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

type Required<T> = {
    [K in keyof T]-?: T[K];
};

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

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

// Filter properties by type
type StringKeys<T> = {
    [K in keyof T as T[K] extends string ? K : never]: T[K];
};

type Data = { id: number; name: string; email: string; count: number };
type StringProps = StringKeys<Data>;
// Result: { name: string; email: string }

// Basic conditional type
type IsString<T> = T extends string ? true : false;
type A = IsString<string>;   // true
type B = IsString<number>;   // false

// Extract return type with infer
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

type Func = () => string;
type Result = ReturnType<Func>;  // string

// Extract array element type
type ElementType<T> = T extends (infer U)[] ? U : never;
type Items = ElementType<number[]>;  // number

// Distributive conditional (union)
type ToArray<T> = T extends any ? T[] : never;
type Arrays = ToArray<string | number>;
// Result: string[] | number[] (distributed)

// Non-distributive (tuple)
type ToArrayNonDist<T> = [T] extends [any] ? T[] : never;
type TupleArray = ToArrayNonDist<string | number>;
// Result: (string | number)[] (not distributed)

// Complex conditional - function overloads
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
type Value1 = UnwrapPromise<Promise<string>>;  // string
type Value2 = UnwrapPromise<number>;           // number

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