TypeScript

Overview

Knowledge Map

typescript/
├── project-system/       # tsconfig.json, build tools, bundlers, compilation
├── package-management/   # npm, yarn, pnpm, bun, workspaces, publishing
├── cli/                  # Commander, yargs, oclif, ink, chalk, CLI tooling
└── packages/             # Popular libraries (Express, Next.js, Zod, Prisma, etc.)

Choosing Guide

project-system

project-system

project-system

package-management

package-management

package-management

cli

cli

packages

TypeScript Version Landscape

in

override

static

Awaited

type

--target es2022

extends

infer

moduleSuffixes

--build

--watch

satisfies

in

const

--moduleResolution bundler

undefined

@param

using

--resolution-mode

/// <reference>

switch (true)

NoInfer

Object.groupBy

Map.groupBy

isolatedDeclarations

Core Language Features Quick Reference

Type System Fundamentals

// Union types — value can be one of several types
type Result = "success" | "error" | "pending";
type ID = string | number;

// Intersection types — combine multiple types
type Employee = Person & { employeeId: string };

// Generics — parameterized types
function first<T>(arr: T[]): T | undefined {
  return arr[0];
}

// Conditional types — type-level if/else
type IsString<T> = T extends string ? true : false;

// Mapped types — transform properties
type Readonly<T> = { readonly [K in keyof T]: T[K] };
type Optional<T> = { [K in keyof T]?: T[K] };

// Template literal types — string manipulation at the type level
type EventName<T extends string> = `on${Capitalize<T>}`;
type ClickEvent = EventName<"click">; // "onClick"

// satisfies operator — validate type without widening
const palette = {
  red: [255, 0, 0],
  green: "#00ff00",
} satisfies Record<string, string | number[]>;

// const assertions — narrow to literal types
const routes = ["home", "about", "contact"] as const;
type Route = (typeof routes)[number]; // "home" | "about" | "contact"

// Discriminated unions — tagged union pattern
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: 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;
  }
}

Key Utility Types

Partial<T>

Partial<User>

Required<T>

Required<Config>

Readonly<T>

Readonly<State>

Pick<T, K>

Pick<User, "id" | "name">

Omit<T, K>

Omit<User, "password">

Record<K, V>

Record<string, number>

Exclude<T, U>

Exclude<Status, "deleted">

Extract<T, U>

Extract<Event, { type: "click" }>

NonNullable<T>

NonNullable<string | null>

ReturnType<T>

ReturnType<typeof fetch>

Parameters<T>

Parameters<typeof setTimeout>

Awaited<T>

Awaited<Promise<string>>

NoInfer<T>

NoInfer<T>

Runtime Options

tsc

ts-node

tsx

esbuild

swc

.ts

Choosing a Runtime

• Building a production server or API? Node.js has the broadest library support and hosting options.
• Want built-in TypeScript with no config? Deno runs

  .ts

  natively with LSP and formatter included.
• Need maximum startup speed or an all-in-one tool? Bun combines runtime, bundler, package manager, and test runner.
• Deploying at the edge? Cloudflare Workers provide sub-millisecond cold starts globally.

Best Practices

1. Enable

   strict

   mode in every project. It enables

   strictNullChecks

   ,

   noImplicitAny

   ,

   strictFunctionTypes

   , and other flags that catch real bugs.
2. Avoid

   any

   — it disables all type checking. Use

   unknown

   when the type is truly unknown, then narrow with type guards.
3. Prefer

   unknown

   over

   any

   for values of uncertain type:
   typescript

   function parse(input: unknown): Config {
     if (typeof input === "object" && input !== null && "port" in input) {
       return input as Config;
     }
     throw new Error("Invalid config");
   }

4. Use type narrowing instead of type assertions:
   typescript

   // Prefer this
   if (typeof value === "string") {
     console.log(value.toUpperCase());
   }
   // Over this
   console.log((value as string).toUpperCase());

5. Use branded types for domain identifiers to prevent mixing:
   typescript

   type UserId = string & { __brand: "UserId" };
   type OrderId = string & { __brand: "OrderId" };
   
   function getUser(id: UserId): User { /* ... */ }
   // getUser(orderId) — compile error!

6. Use

   satisfies

   to validate object shapes without widening types.
7. Use

   const

   assertions for literal tuples and objects that should not be widened.
8. Use discriminated unions for state machines and variant types instead of optional properties.
9. Enable

   noUncheckedIndexedAccess

   to force undefined checks on dynamic property access.
10. Keep

    any

    out of library boundaries — validate external data at the edge with Zod, io-ts, or similar runtime validators.