Building a TypeScript Reference PDF You'll Actually Open

I've been writing TypeScript for six years.

I still can't tell you what extends infer does without looking it up.

I'm not embarrassed about this. The TypeScript type system is genuinely deep. The "I know all of this" people are usually bluffing.

What I am embarrassed about: the number of tabs I open looking up the same five things over and over.

This is the setup that fixed it.

Table of Contents

• The TS Handbook Problem
• The Bundle
• The "Type Plumbing" Reading Sequence
• Quick-Reference vs Deep-Dive Formats
• A Note on TS Versions
• What About tsdoc?
• A Real Habit Change
• Generate Your TS Reference

The TS Handbook Problem

The TypeScript handbook is large.

Most of us have read 20% of it. We know the part we use daily — interfaces, generics, the basics — and the rest sits there waiting for the day we need it.

The day always comes. Usually mid-PR review.

Reading the whole handbook in one go isn't realistic. But having the whole thing in a PDF on your desktop, searchable, marked up where you've actually used something? That changes how often you reach for it.

The Bundle

I bundle three things into one PDF:

1. The TypeScript Handbook (https://www.typescriptlang.org/docs/handbook/intro.html)
2. The Cheat Sheet (the official one TS ships)
3. Utility types reference

The result is roughly 350 pages. Not for cover-to-cover reading. For the question I have right now.

The workflow:

1. OfflineDocs
2. Paste the handbook URL
3. Use the bundle option to add the cheat sheet pages
4. Generate

Same from-url method we use for GitHub READMEs and every other doc bundle.

The "Type Plumbing" Reading Sequence

If you want to actually learn the deep type system (not just keep it as a reference), here's the reading order that works:

That's roughly the path from "I write TypeScript" to "I write type-level TypeScript."

Most working developers will live happily through "Generics" and stop there. That's fine. But knowing where to find the deep stuff when you need it is half the battle.

Quick-Reference vs Deep-Dive Formats

I keep two PDFs:

Deep-dive (350 pages, full handbook + utility types): lives on the iPad. Reading mode.

Quick-reference (~30 pages, cheat sheet + utility types only): lives printed and clipped on my desk. Lookup mode.

The cheat sheet is genuinely under-loved. It has more dense information per page than any other resource the TS team publishes. Worth printing, worth annotating, worth pinning above your monitor.

If you want to actually print the quick-reference, there's a separate guide on print optimization.

A Note on TS Versions

Pin your TS version when generating.

https://www.typescriptlang.org/docs/handbook/intro.html is current. The handbook gets updated for new releases.

Your team is on TS 5.7? Generate the 5.7 PDF before they roll forward. Then when 5.8 ships and adds a new feature you don't use yet, your reference is still relevant.

This trick matters less for TypeScript than for, say, the Anthropic API, but the principle is the same: pinning a reference to a known version is a small superpower.

What About tsdoc?

tsdoc is for documenting your TS code (in the JSDoc style). Different problem.

What we're solving here is "I want to read TypeScript's docs offline." If you also want to read your team's tsdoc-generated docs offline, that's a separate generation step — feed the rendered output to OfflineDocs as a from-url source, same as anything else.

A Real Habit Change

After bundling the TS reference, the most useful behavior change in my workflow:

When I'm stuck on a type, I open the PDF before I open Stack Overflow.

Most of the time, the answer is in the handbook. I just hadn't read that section.

The Stack Overflow detour costs me 15-20 minutes most of the time. The PDF lookup costs me 30 seconds.

That math is the whole reason this article exists.

Generate Your TS Reference

offlinedocs.ai/new → paste https://www.typescriptlang.org/docs/handbook/intro.html → generate.

Two minutes. One PDF. One fewer reason to context-switch into your browser when a type confuses you.

Try it next time you stare at a Conditional<T extends infer U ? U : never> and feel your brain melt.