How TypeScript refines types through control flow — predicates, discriminants, and patterns that keep strict mode honest.

intermediate

A practical on-ramp: what TS adds to JS, strict mode basics, gradual migration, and the frontend patterns that matter first.

beginner

Primitives, arrays, objects, and function annotations TypeScript actually checks — plus where inference is enough and where it is not.

beginner

Type component props with required/optional fields, children, unions for variants, and HTML attribute extension patterns.

beginner

When to use interface vs type in TypeScript — extension, unions, declaration merging, and a practical default for frontend apps.

beginner

Combine types with | and & — model alternatives, mixins, and why unions need narrowing while intersections require all members.

beginner

Correct event types for onClick, onChange, forms, and keyboard handlers in React TypeScript — synthetic events and target narrowing.

intermediate

String, number, and boolean literal types — model fixed variants, narrow with equality, and combine with unions for safe UI props.

beginner

Built-in typeof and instanceof narrowing, custom type predicates, and how guards differ from assertions in TypeScript.

beginner

Model loading, success, and error as mutually exclusive variants so TypeScript and your UI cannot show impossible states.

intermediate

Type parameters for functions, components, and data structures — constraints, inference, and the mistakes that produce any-shaped APIs.

intermediate

Limit type parameters with extends so generics stay flexible but can safely use properties like id, length, or keyof T.

intermediate

Derive keys and value types from objects with keyof, typeof, and T[K] — the toolkit behind typed forms, configs, and safe property access.

intermediate

Use Partial, Required, Pick, Omit, and Record to reshape props and DTOs without rewriting object types by hand.

beginner

Freeze intent with readonly, Readonly<T>, and as const — keep literal types, prevent accidental mutation, and type config objects correctly.

intermediate

When TypeScript enums help, when they hurt, and why string literal unions plus const objects win for most frontend code.

intermediate

Declare multiple call signatures so one implementation returns different types based on arguments — without lying with unions everywhere.

advanced

Fixed-length arrays with per-position types — useState pairs, CSV rows, rest parameters, and labeled tuples in TypeScript.

intermediate

Why unknown is the type-safe top type, how to narrow it, and when any is a deliberate escape hatch — not a default.

beginner

What strict mode actually enables, flag-by-flag impact on frontend code, and a practical migration order for legacy apps.

intermediate

What value! means in TypeScript, when non-null assertions are justified, and safer patterns that keep strictNullChecks honest.

intermediate

When as Type is justified, why double assertions are a smell, and how to replace casts with narrowing, guards, and validation.

intermediate

Type HTTP JSON safely — Response generics myths, unknown + schema parse, error unions, and React Query-friendly patterns.

intermediate

Type props that depend on item shape — lists, selects, and tables — with generic components, inference pitfalls, and TSX syntax quirks.

advanced

TypeScript types erase at runtime — validate JSON and form input with Zod (or similar) so parsed data is actually typed and safe.

intermediate

Check a value against a type while keeping the narrow inferred type — config objects, route maps, and as const without losing literals.

intermediate

Build string types with `on${Event}`, extract route params, and type CSS-like APIs using TypeScript template literal types.

advanced

T extends U ? X : Y — how TypeScript picks types from conditions, distributes over unions, and powers utility types you already use.

advanced

Transform every property of a type with {[K in keyof T]: …} — the engine behind Partial, Readonly, Pick patterns, and typed form bags.

advanced

How .d.ts files describe JS to TypeScript, when to use @types packages, module augmentation, and writing minimal ambient types for untyped libs.

intermediate

Keep tsconfig paths, bundler aliases, Vitest, and ESLint in sync so @/ imports resolve everywhere — not just in the IDE.

intermediate

Use infer inside conditional types to extract return types, promise payloads, array elements, and function parameters.

advanced

Nominal-style UserId vs OrderId in TypeScript — prevent ID mixups at compile time with brands, parsers, and form boundaries.

advanced

Type form values, errors, touched flags, and dirty maps with Record, Partial, and keyof so field names stay in sync.

intermediate

Use the in operator to narrow unions by property presence — object shapes, optional fields, and when in is the wrong tool.

beginner

What never means, how exhaustive switches use it, and why unreachable code and empty unions show up in TypeScript errors.

intermediate