Typescript Cookbook Real World Type-Level Programming (Stefan Baumgartner)（Z-Library）

# TypeScript Cookbook: Real World Type-Level Programming ## 【One-Line Pitch】 A practical, discussion-first cookbook for senior developers who want to master TypeScript's type system through real-world recipes, from project setup to advanced helper types. If you're comfortable with TypeScript basics but frustrated by compiler errors and type-level complexity, this book gives you both solutions and the reasoning behind them. ## 【Book Arc】 - **Opening (~0%–9%)**: Project setup fundamentals — configuration options, strict mode, Definitely Typed packages, and the philosophy that this is a "discussion book" where trade-offs matter more than one-size-fits-all answers. - **Early (~9%–25%)**: Basic types and type system mechanics — annotations, the type hierarchy, object types, and the critical distinction between `{}`, `Object`, and `object`. Includes practical setup patterns like separating dev and build tsconfigs for test runners. - **Early (~25%–34%)**: Function typing and type design — overloads, symbols, and the performance debate between interfaces and type aliases, with guidance on when each is appropriate. - **Middle (~34%–47%)**: The type system in depth — union and intersection types, discriminated unions, exhaustiveness checking with `never`, index signatures, and enums with their nominal typing caveats. - **Middle (~47%–end)**: Advanced territory — conditional types, string template literal types, mapping types, `ThisType`, and helper types that work across projects, plus React integration and best practices for type development. ## 【Key Takeaways】 - **Strict mode is a moving target** (Early): TypeScript's strict mode encodes the team's evolving view of correct type behavior, so updates can break code. Turn individual strict features on/off to control migration pace. - **Separate dev and build configs for test globals** (Early): Use a `tsconfig.base.json` shared by a dev config (includes Mocha/Jest globals) and a build config that excludes test files — prevents type errors from test-only globals leaking into production compilation. - **`{}`, `Object`, and `object` are not interchangeable** (Early): `{}` and `Object` accept everything except `null`/`undefined`, while `object` only accepts compound types. Choose based on whether you need to exclude primitives. - **Type aliases vs. interfaces is a performance non-issue** (Early): Performance differences only appear at ~5,000 declarations, so choose based on semantics — interfaces for declaration merging and public APIs, type aliases for module-internal types. - **Union types are sets, and overlap is a trap** (Middle): An object with both `material` and `players` properties fits both `Doll` and `BoardGame` in a union. Discriminated unions (Recipe 3.2) solve this by adding a literal `kind` field. - **`never` is the empty set and your exhaustiveness checker** (Middle): In a `switch` over a discriminated union, the `default` branch narrows to `never` — if you add a new variant, the type in `default` changes to that variant, alerting you to missing handling. - **Index signatures need `| undefined` for realism** (Middle): `{ [key: string]: Metrics }` lets you read missing properties without errors; `{ [key: string]: Metrics | undefined }` forces you to handle absence, which matches runtime reality. - **String enums are nominal, not structural** (Middle): Unlike every other TypeScript type, two string enums with identical values are incompatible. This causes friction when receiving strings from external sources — use enums only for feature flags or internal constants. ## 【Reading Tips】 - **Skim Chapter 1 if you have a working setup** — the tsconfig patterns are useful, but the real value starts with Chapter 3's type system discussion. - **Deep-read Chapter 3 (The Type System)** — union/intersection types, discriminated unions, and exhaustiveness checking are the foundation for everything later. The Venn diagram visualization of union types is worth internalizing. - **Treat each recipe as a discussion starter, not a final answer** — the author explicitly says no single solution fits all problems. Read the "Discussion" sections to understand trade-offs, not just copy solutions. - **Watch for the `never` pattern in `default` branches** — it's the single most useful technique for maintaining large discriminated unions as your codebase grows. - **Skip the performance debate between interfaces and type aliases** — the author debunks it; focus instead on the semantic differences (merging, extension, consumption patterns). ## 【Coverage Limits】 This guide synthesizes the opening through middle sections (~47% of the book). The advanced chapters on conditional types, template literal types, mapping types, and React integration are listed in the table of contents but not covered in detail here. ##