TypeScript Patterns

TypeScript Patterns (Strict)

When to use this skill

Use this skill when working in a strict TypeScript codebase and you want reliable patterns for modeling data, narrowing, generics, and configuration—without papering over errors with as casts.

Core patterns

Strict mode is the baseline

Prefer strict: true and keep these on unless you have a strong reason:

• noUncheckedIndexedAccess
• exactOptionalPropertyTypes
• noImplicitOverride (when using classes)

Treat any relaxation as a conscious decision with a documented reason.

unknown over any

Use unknown at boundaries:

• JSON parsing
• tool outputs
• external SDK payloads

Then narrow:

function isRecord(x: unknown): x is Record<string, unknown> {
  return typeof x === "object" && x !== null;
}

Narrowing patterns

Use the built-in primitives:

• typeof for primitives
• instanceof for classes/errors
• "in" for structural checks
• discriminated unions for complex state

type Result =
  | { ok: true; value: string }
  | { ok: false; error: string };

function handle(r: Result) {
  if (!r.ok) return r.error;
  return r.value;
}

Discriminated unions for UI state

Avoid boolean soup (isLoading, hasError, isEmpty …). Prefer:

type LoadState =
  | { kind: "idle" }
  | { kind: "loading" }
  | { kind: "error"; message: string }
  | { kind: "ready"; items: string[] };

Utility types (use them deliberately)

Useful:

• Pick, Omit for DTO shaping
• ReturnType, Parameters for typed wrappers
• Partial only for “patch” objects (not for real domain models)

Anti-pattern:

• Partial<Model> to “get around” missing required fields

satisfies > type assertions

Prefer:

const routes = {
  home: "/",
  settings: "/settings",
} satisfies Record<string, string>;

Avoid:

• as Record<string, string> (it can lie)

as const for literal preservation

Use as const to keep literals and readonly tuples:

const roles = ["admin", "user"] as const;
type Role = (typeof roles)[number];