TypeScript cheat sheet

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; // shape is the circle here
    case "rectangle":
      return shape.width * shape.height;
    case "triangle":
      return (shape.base * shape.height) / 2;
    default: {
      const unhandled: never = shape;
      throw new Error(`Unknown shape: ${JSON.stringify(unhandled)}`);
    }
  }
}
 
const shapes: Shape[] = [
  { kind: "circle", radius: 1 },
  { kind: "rectangle", width: 3, height: 4 },
  { kind: "triangle", base: 6, height: 2 },
];
 
for (const shape of shapes) {
  console.log(shape.kind, area(shape).toFixed(2));
}
// circle 3.14
// rectangle 12.00
// triangle 6.00

interface Entity {
  id: number;
}
 
class Store<T extends Entity> {
  #items = new Map<number, T>();
  #nextId = 1;
 
  add(data: Omit<T, "id">): T {
    const item = { ...data, id: this.#nextId++ } as T;
    this.#items.set(item.id, item);
    return item;
  }
 
  update(id: number, changes: Partial<Omit<T, "id">>): T {
    const current = this.#items.get(id);
    if (!current) {
      throw new Error(`No item with id ${id}`);
    }
    const updated = { ...current, ...changes };
    this.#items.set(id, updated);
    return updated;
  }
 
  find<K extends keyof T>(key: K, value: T[K]): T[] {
    return [...this.#items.values()].filter((item) => item[key] === value);
  }
}
 
interface Task extends Entity {
  title: string;
  done: boolean;
  priority: "low" | "high";
}
 
const tasks = new Store<Task>();
tasks.add({ title: "Write the cheat sheet", done: false, priority: "high" });
tasks.add({ title: "Feed the cat", done: false, priority: "high" });
tasks.update(2, { done: true });
 
console.log(tasks.find("priority", "high").length); // 2
console.log(tasks.find("done", true).map((t) => t.title)); // [ 'Feed the cat' ]
 
// @ts-expect-error: "urgent" is not "low" | "high"
tasks.find("priority", "urgent");
// @ts-expect-error: id is left out of the input type
tasks.add({ id: 99, title: "Sneaky", done: false, priority: "low" });

type Colour = `#${string}`;
 
// 1. An annotation: checked, but the specific keys are forgotten
const annotated: Record<string, Colour> = { primary: "#f5c518", text: "#111111" };
annotated.primry; // a typo, and no error: every string key is allowed
 
// 2. satisfies: checked, and the keys are kept
const theme = { primary: "#f5c518", text: "#111111" } satisfies Record<string, Colour>;
// @ts-expect-error: Property 'primry' does not exist
theme.primry;
const primary: Colour = theme.primary; // fine: the value type is still checked
 
// @ts-expect-error: "red" does not match `#${string}`
const broken = { primary: "red" } satisfies Record<string, Colour>;
 
// 3. as: no check at all
const guessed = { primary: "red" } as unknown as Record<string, Colour>; // compiles, and is wrong
 
// as const satisfies: exact values, still checked
const sizes = { sm: 640, md: 768, lg: 1024 } as const satisfies Record<string, number>;
type Breakpoint = keyof typeof sizes; // "sm" | "md" | "lg"
const widest: 1024 = sizes.lg;
 
console.log(primary, widest, Object.keys(annotated).length, broken, guessed);

interface User {
  id: number;
  name: string;
  email?: string;
}
 
function isUser(value: unknown): value is User {
  return (
    typeof value === "object" &&
    value !== null &&
    "id" in value &&
    typeof value.id === "number" &&
    "name" in value &&
    typeof value.name === "string" &&
    (!("email" in value) || typeof value.email === "string")
  );
}
 
function parseUsers(json: string): User[] {
  const data: unknown = JSON.parse(json);
  if (!Array.isArray(data)) {
    throw new TypeError("Expected an array of users");
  }
  return data.filter(isUser);
}
 
const body = '[{"id":1,"name":"Ada"},{"id":"2","name":"Grace"},{"id":3,"name":"Linus","email":"l@example.com"}]';
 
const users = parseUsers(body);
console.log(users.map((u) => u.name)); // [ 'Ada', 'Linus' ]: Grace's id is a string
 
try {
  parseUsers('{"id":1}');
} catch (err) {
  if (err instanceof Error) {
    console.log(err.message); // Expected an array of users
  }
}

{
  "compilerOptions": {
    // Where the code runs
    "target": "es2025",
    "module": "nodenext",
    "lib": ["es2025"],
    "types": ["node"],
 
    // Output
    "rootDir": "src",
    "outDir": "dist",
    "sourceMap": true,
 
    // Checks beyond strict, which is on by default
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true,
    "noImplicitOverride": true,
 
    // Keep each file compilable on its own
    "verbatimModuleSyntax": true,
    "isolatedModules": true,
    "skipLibCheck": true
  },
  "include": ["src"]
}