// Without strictNullChecks — this compiles and crashes at runtime
function getLength(str: string): number {
  return str.length  // str could be null or undefined at runtime
}

// With strictNullChecks — forced to handle the null case
function getLength(str: string | null): number {
  if (str === null) return 0
  return str.length  // ✅ safe
}

// tsconfig.json: "exactOptionalPropertyTypes": true

interface Options {
  timeout?: number  // Intended: "not provided" vs "provided a number"
}

// ❌ With exactOptionalPropertyTypes, explicitly setting to undefined is an error
const opts: Options = { timeout: undefined }
// Error: Type 'undefined' is not assignable to type 'number' with exactOptionalPropertyTypes

// ✅ Correct: simply omit the property
const opts2: Options = {}  // timeout is absent — that's the intent

// Without noUncheckedIndexedAccess (default)
const arr: number[] = [1, 2, 3]
const first: number = arr[0]      // ✅ Compiles — but arr[99] would also be `number`, not `undefined`

// With noUncheckedIndexedAccess
const first2 = arr[0]             // number | undefined — accurately reflects runtime behavior
const value = first2 * 2          // ❌ Error: first2 might be undefined
const value2 = first2 ?? 0 * 2   // ✅ Safe — handle the undefined case

class Base {
  render(): string { return '<base>' }
}

// ❌ Without noImplicitOverride — silent override; renamed parent method = runtime bug
class Child extends Base {
  render(): string { return '<child>' }  // Is this intentional? TypeScript doesn't know.
}

// ✅ With noImplicitOverride — intent is explicit
class Child extends Base {
  override render(): string { return '<child>' }  // Compiler verifies the parent method exists
}

// ❌ `const enum` — requires the full compilation unit to inline values
const enum Direction { Up, Down, Left, Right }

// ❌ Re-exporting a type without `type` keyword
export { SomeType }        // Ambiguous — is this a value or a type-only export?
export type { SomeType }   // ✅ Explicit — esbuild knows to elide this
import type { SomeType } from './types'  // ✅ Always use `import type` for type-only imports

// ❌ verbatimModuleSyntax rejects this if User is a type-only import
import { User, processUser } from './types'

// ✅ Explicit split — the compiler can elide `import type` cleanly
import type { User } from './types'
import { processUser } from './utils'

type Palette = Record<string, [number, number, number] | string>

// ❌ Type annotation — widens to Palette, losing the specific inferred types
const palette: Palette = {
  red:   [255, 0, 0],
  green: '#00ff00',
}
palette.red    // [number, number, number] | string — too wide
palette.red.map(...)  // ❌ Error — not guaranteed to be an array

// ✅ satisfies — validates shape AND preserves the inferred literal types
const palette2 = {
  red:   [255, 0, 0],
  green: '#00ff00',
} satisfies Palette

palette2.red    // [number, number, number] — specific, not widened
palette2.red.map(v => v / 255)  // ✅ Safe — TypeScript knows it's a tuple
palette2.blue   // ❌ Error — satisfies still validates missing required keys

// packages/ui/tsconfig.json
{
  "compilerOptions": {
    "composite": true,   // Required for project references
    "outDir": "./dist",
    "declaration": true
  },
  "references": [
    { "path": "../core" }  // Declares a dependency on packages/core
  ]
}

# Build with incremental compilation — only rebuilds changed packages
npx tsc --build

# Check types without emitting
npx tsc --build --dry