typescript-strict

Enforce strict TypeScript practices:

No any

Never use any. Use unknown for truly unknown types:

// ❌ Avoid
function process(data: any) { }

// ✅ Better
function process(data: unknown) {
  if (typeof data === 'string') {
    // Now TypeScript knows it's a string
  }
}

Explicit Return Types

Add explicit return types for public/exported functions:

// ✅ Explicit return type
function calculateTotal(items: Item[]): number {
  return items.reduce((sum, item) => sum + item.price, 0)
}

// ✅ For async functions
async function fetchUser(id: string): Promise<User | null> {
  // ...
}

Interface over Type

Prefer interface for object shapes (better error messages, extendable):

// ✅ Prefer interface
interface User {
  id: string
  name: string
  email: string
}

// Use type for unions, primitives, or complex types
type Status = 'pending' | 'active' | 'done'
type Nullable<T> = T | null

Readonly

Mark immutable data as readonly:

interface Config {
  readonly apiUrl: string
  readonly maxRetries: number
}

function processItems(items: readonly Item[]) {
  // items.push() would be an error
}

Type Guards

Use type guards for runtime type checking:

function isUser(value: unknown): value is User {
  return (
    typeof value === 'object' &&
    value !== null &&
    'id' in value &&
    'name' in value
  )
}

if (isUser(data)) {
  // TypeScript knows data is User
  console.log(data.name)
}

Const Assertions

Use as const for literal types:

const STATUSES = ['pending', 'active', 'done'] as const
type Status = typeof STATUSES[number] // 'pending' | 'active' | 'done'

Non-null Assertion

Avoid ! when possible. Use optional chaining or type guards:

// ❌ Risky
const name = user!.name

// ✅ Safer
const name = user?.name ?? 'Unknown'