typescript-patterns

TypeScript Patterns

Overview

Advanced TypeScript patterns that use the type system to prevent runtime errors. Focuses on strict mode TypeScript with patterns for type inference, narrowing, and compile-time validation. Not a beginner tutorial.

When to use: Building type-safe APIs, complex data transformations, library authoring, preventing runtime errors through types, working with strict mode flags.

When NOT to use: Learning TypeScript basics (primitives, interfaces, classes), JavaScript-to-TypeScript migration guidance, tooling setup, or build configuration.

Quick Reference

Pattern	API	Key Points
Utility types	Pick<T, K>, Omit<T, K>	Extract or exclude properties
Partial/Required	Partial<T>, Required<T>	Make properties optional or required
Record type	Record<K, V>	Object with known keys
Awaited type	Awaited<T>	Unwrap Promise return types
ReturnType/Parameters	ReturnType<F>, Parameters<F>	Extract function types
Generic constraints	<T extends Type>	Constrain generic parameters
Type inference	type Inferred = typeof value	Let TypeScript infer from values
Type guards	typeof, instanceof, in	Narrow types at runtime
Custom type guards	(x): x is Type	User-defined narrowing functions
Inferred predicates	(x) => x !== null	Auto-inferred type predicate filters
Discriminated unions	Union with literal type property	Exhaustive pattern matching
Conditional types	T extends U ? X : Y	Type-level conditionals
Mapped types	{ [K in keyof T]: T[K] }	Transform all properties
Template literals	`${A}-${B}`	String literal type manipulation
Const assertions	as const	Narrowest possible literal types
Satisfies operator	value satisfies Type	Type check without widening
NoInfer utility	NoInfer<T>	Prevent inference from a position
Const type params	<const T extends Type>	Narrow inference without as const
Inline type imports	import { type User }	Import types explicitly
Module augmentation	declare module 'lib' { ... }	Extend third-party types
Assertion functions	function assert(x): asserts x is T	Throw if type guard fails

Common Mistakes

Mistake	Correct Pattern
Using any without justification	Use unknown and narrow with type guards
Manual type assertions everywhere	Let inference work, type function returns
Destructuring before type narrowing	Keep object intact for discriminated unions
Index access without undefined check	Enable noUncheckedIndexedAccess
as Type casting unsafe values	Use satisfies Type to preserve narrow types
Inline objects in generics	Extract to const or type alias
Omitting extends in constraints	Always constrain generics when possible
Using Parameters<typeof fn>[0]	Type the parameter directly in function
Not handling union exhaustiveness	Use never checks in switch/if-else
value as const satisfies Type	Use satisfies Type then as const if needed

Delegation

• Pattern discovery: Use Explore agent to find existing patterns in codebase
• Type error debugging: Use Task agent for multi-step type resolution
• Code review: Delegate to code-reviewer skill for type safety audit

References

• Type utilities (Pick, Omit, Partial, Required, Record, Extract, Exclude, ReturnType, Parameters, Awaited)
• Generics (constraints, inference, default parameters, variance)
• Type guards and narrowing (typeof, instanceof, in, custom guards, assertion functions)
• Discriminated unions (exhaustive checking, never type, tagged unions)
• Conditional types (distributive conditionals, infer keyword, type-level logic)
• Mapped types (key remapping, template literals, modifiers)
• Strict mode patterns (noUncheckedIndexedAccess, exactOptionalPropertyTypes, const assertions, satisfies)
• Module patterns (inline type imports, declaration files, module augmentation, ambient types)
• Modern idioms (eslint-plugin-unicorn patterns, modern array/string/DOM APIs, ES modules)