Practice TypeScript

type UserProfile = {
  id: number;
  username: string;
  email: string;
  age?: number;
  role: "admin" | "editor" | "viewer";
};

const me: UserProfile = {
  id: 1,
  username: "jsmith",
  email: "jsmith@example.com",
  role: "editor",
};

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

function swap<A, B>(pair: [A, B]): [B, A] {
  const [a, b] = pair;
  return [b, a];
}

// Demonstrate inference
const num = identity(42);           // T inferred as number
const str = identity("hello");      // T inferred as string
const swapped = swap(["ts", 100]);  // [number, string]

function formatValue(value: string | number | boolean): string {
  if (typeof value === "number") {
    return value.toFixed(2);
  }
  if (typeof value === "boolean") {
    return value ? "yes" : "no";
  }
  return '"' + value + '"';
}

console.log(formatValue(3.14159)); // "3.14"
console.log(formatValue(true));    // "yes"
console.log(formatValue("hello")); // "\"hello\""

interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
  inStock: boolean;
}

type ProductPreview = Pick<Product, "id" | "name" | "price">;
type ProductUpdate  = Partial<Omit<Product, "id">>;
type ProductCatalog = Record<string, Product>;

// Example values
const preview: ProductPreview = { id: 1, name: "Widget", price: 9.99 };

const update: ProductUpdate = { price: 7.99, inStock: false };

const catalog: ProductCatalog = {
  "WDG-001": {
    id: 1,
    name: "Widget",
    price: 9.99,
    description: "A small widget",
    inStock: true,
  },
};

class Stack<T> {
  private items: T[] = [];

  push(item: T): void {
    this.items.push(item);
  }

  pop(): T | undefined {
    return this.items.pop();
  }

  peek(): T | undefined {
    return this.items[this.items.length - 1];
  }

  get size(): number {
    return this.items.length;
  }

  isEmpty(): boolean {
    return this.items.length === 0;
  }
}

// Usage demonstration
const words = new Stack<string>();
words.push("hello");
words.push("world");
console.log(words.peek());  // "world"
console.log(words.size);    // 2
console.log(words.pop());   // "world"
console.log(words.size);    // 1

const nums = new Stack<number>();
console.log(nums.isEmpty()); // true
nums.push(10);
nums.push(20);
console.log(nums.pop());     // 20

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

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

type MyNullable<T> = {
  [K in keyof T]: T[K] | null;
};

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

const p1: MyPartial<Point> = { x: 1 };                    // y and label omitted — OK
const p2: MyReadonly<Point> = { x: 0, y: 0, label: "O" }; // cannot reassign any field
const p3: MyNullable<Point> = { x: null, y: 4, label: null };

type Result<T, E> =
  | { ok: true; value: T }
  | { ok: false; error: E };

function succeed<T>(value: T): Result<T, never> {
  return { ok: true, value };
}

function fail<E>(error: E): Result<never, E> {
  return { ok: false, error };
}

function unwrap<T, E>(result: Result<T, E>): T {
  if (result.ok) {
    return result.value;
  }
  throw result.error instanceof Error
    ? result.error
    : new Error(String(result.error));
}

// Usage
const good = succeed(42);
console.log(unwrap(good)); // 42

const bad = fail("something went wrong");
try {
  unwrap(bad);
} catch (e) {
  console.error((e as Error).message); // "something went wrong"
}

type ListenerMap<Events> = {
  [K in keyof Events]?: Array<(payload: Events[K]) => void>;
};

class EventEmitter<Events extends Record<string, unknown>> {
  private listeners: ListenerMap<Events> = {};

  on<K extends keyof Events>(event: K, listener: (payload: Events[K]) => void): void {
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    (this.listeners[event] as Array<(p: Events[K]) => void>).push(listener);
  }

  off<K extends keyof Events>(event: K, listener: (payload: Events[K]) => void): void {
    const arr = this.listeners[event] as Array<(p: Events[K]) => void> | undefined;
    if (arr) {
      this.listeners[event] = arr.filter((l) => l !== listener) as typeof arr;
    }
  }

  emit<K extends keyof Events>(event: K, payload: Events[K]): void {
    const arr = this.listeners[event] as Array<(p: Events[K]) => void> | undefined;
    arr?.forEach((l) => l(payload));
  }
}

// Usage
type AppEvents = {
  login: { userId: string };
  logout: { userId: string };
  error: { message: string };
};

const emitter = new EventEmitter<AppEvents>();

function onLogin(payload: { userId: string }) {
  console.log("User logged in:", payload.userId);
}

emitter.on("login", onLogin);
emitter.on("error", (p) => console.error("Error:", p.message));

emitter.emit("login", { userId: "u_001" });  // "User logged in: u_001"
emitter.emit("error", { message: "Disk full" });

emitter.off("login", onLogin);
emitter.emit("logout", { userId: "u_001" }); // no listeners — silent