TypeScript Advanced FAQ & Answers

Variance annotations (TypeScript 4.7+): Explicit syntax to declare how generic type parameters behave in subtyping relationships - eliminates inference ambiguity and improves performance. Syntax: (1) out T (covariant): Type parameter appears only in output/return positions - allows assigning subtype to supertype variable. Example: type Producer<out T> = () => T; means Producer<Dog> is assignable to Producer<Animal> (Dog is subtype of Animal). (2) in T (contravariant): Type parameter appears only in input/parameter positions - allows assigning supertype to subtype variable (reversed). Example: type Consumer<in T> = (val: T) => void; means Consumer<Animal> is assignable to Consumer<Dog> (can handle any Dog since it handles all Animals). (3) No annotation (invariant): Type parameter in both positions - strict equality required, no subtype substitution. Before 4.7 (inference problems): (1) Structural inference: TypeScript examined all usages to infer variance - slow for complex types (could take seconds), error-prone (incorrect inference for edge cases). (2) Bivariant parameter errors: Function parameters bivariant by default (unsound), leading to false negatives in type checking. (3) Performance issues: Deep inference chains in large codebases caused 10-100x slowdowns during type-checking. Benefits of explicit annotations (2025): (1) Type-checking performance: 50-90% faster for generic-heavy codebases (libraries, frameworks) - compiler skips inference, uses declared variance. (2) Earlier error detection: Variance errors caught at type declaration site, not usage site (better error messages, easier debugging). (3) Soundness guarantees: Eliminates bivariant parameter bugs - strict contravariance for inputs. (4) Better IDE responsiveness: Faster autocomplete, hover info, error squiggles in VS Code/WebStorm. Common use cases (2025): (1) Event emitters: interface EventEmitter<out T> { on(listener: (event: T) => void): void; } - events are output-only. (2) Promise/Observable types: type Observable<out T> = { subscribe(observer: (val: T) => void): void; } - values produced, not consumed. (3) State management: type Store<out S> = { getState(): S; subscribe(listener: () => void): void; } - state is read-only output. (4) Dependency injection containers: interface Container { resolve<out T>(token: Token<T>): T; } - produces instances. (5) Validators: type Validator<in T> = (value: T) => ValidationResult; - consumes values for validation. Rule of thumb: (1) Use out T: Return types, readonly properties, promise values, observable streams, getter methods. (2) Use in T: Function parameters, setter methods, event handlers, validators, comparators. (3) Omit annotation (invariant): Mutable containers (arrays, maps), read-write properties, types with both getters and setters. Example - API client (2025): interface ApiClient<out TResponse, in TRequest> { get(): Promise<TResponse>; post(data: TRequest): Promise<void>; }. TResponse covariant (produces responses), TRequest contravariant (consumes requests). Allows flexible subtyping: ApiClient<UserProfile, CreateUserDTO> assignable to ApiClient<BasicProfile, UserData> (BasicProfile supertype of UserProfile, UserData subtype of CreateUserDTO). Performance benchmarks (2025): Large TypeScript libraries (50K+ lines) see 60-80% faster type-checking with explicit variance on public API types. When to use: (1) Public library APIs (maximize performance for consumers), (2) Complex generic types (eliminate inference ambiguity), (3) Variance-related compiler errors (make intent explicit). When NOT to use: Simple types, internal implementation details, types with <3 generic parameters (inference is fast enough). Best practices: Add variance annotations to public API surface area first (biggest performance gain), use --strictFunctionTypes flag (enforces contravariance for parameters, catches unsound code). TypeScript 5.0+ improvements: Better variance checking for recursive types, improved error messages for variance violations, faster inference for unannotated generics.

Type-safe fluent APIs (2025 patterns): Use polymorphic this type and conditional types to create chainable APIs with compile-time state validation, preventing invalid method sequences and missing required calls. Polymorphic this type (basic pattern): Return this instead of explicit class name to preserve subclass types through inheritance chain. Pattern: class QueryBuilder { private query: string = ''; select(fields: string): this { this.query += fields; return this; } where(condition: string): this { this.query += condition; return this; } }. Benefit: Subclass methods return correct subtype, not base class. Example: class UserQueryBuilder extends QueryBuilder { includeDeleted(): this { return this; } } allows chaining userBuilder.select('*').includeDeleted().where('id > 10') with full type safety. State-tracking builders (advanced pattern): Use conditional types to enforce method call order and required methods. Pattern: type BuilderState<T extends Record<string, boolean>> = { setState(key: K): BuilderState<T & Record<K, true>>; build(): AllRequiredKeysPresent extends true ? FinalResult : 'Error: Missing required methods'; }. Each method call updates type-level state (T & Record<'methodName', true>), build() only succeeds when all required flags are true. Real-world example: HTTP request builder requiring method + URL before send: interface RequestBuilder { method(m: string): RequestBuilder<true, HasURL>; url(u: string): RequestBuilder<HasMethod, true>; send(): HasMethod extends true ? (HasURL extends true ? Promise : 'Missing URL') : 'Missing method'; }. Calling send() without method() or url() produces compile error. TypeScript 5.x enhancements: (1) const type parameters (TS 5.0+): Preserve literal types in builder methods - withHeader(key: K, value: string): BuilderWithHeader infers exact header name ('Content-Type'), not widened string. (2) satisfies operator (TS 4.9+): Validate builder config without losing narrow types - const config = builder.setOptions({ timeout: 5000 }).build() satisfies AppConfig preserves literal 5000, not widened number. Production use cases: (1) Query builders: TypeORM, Prisma, Knex - type-safe SQL query construction with autocomplete for valid methods per query type (SELECT allows WHERE, INSERT doesn't). (2) Test builders: Factory pattern for test fixtures - userBuilder.withEmail('[email protected]').withRole('admin').build() ensures required fields set. (3) Configuration DSLs: Fluent config APIs - configBuilder.database().host('localhost').port(5432).logging().level('debug').enable() with hierarchical method groups. (4) HTTP clients: Axios-style request builders - client.get('/users').headers({ 'Auth': 'token' }).query({ page: 1 }).send() with type-safe chaining. (5) UI component builders: Storybook/testing-library component construction - buttonBuilder.variant('primary').size('large').disabled(true).render(). Performance considerations: (1) Complex state types slow IDE: Deeply nested conditional types (>10 method calls tracked) cause 2-5 second autocomplete delays in VS Code. Workaround: Limit state tracking to critical validations (required methods), not all possible states. (2) Separate interfaces per state: Alternative pattern with better IDE performance - interface InitialBuilder { method(m: string): BuilderWithMethod; }, interface BuilderWithMethod { url(u: string): BuilderWithURL; }, interface BuilderWithURL { send(): Promise; }. More verbose (3-5 interfaces vs 1 conditional type) but 10x faster autocomplete. Use for >20 builder methods. Framework integration: (1) React: Fluent component prop builders - buttonProps().variant('primary').onClick(handler).disabled(false).build() for complex prop combinations. (2) Vue: Composable builders for reactive state - stateBuilder().initial({ name: '' }).validator(validateUser).persist('localStorage').create(). (3) Angular: Service configuration builders - httpClient.get<User[]>('/api/users').withAuth().retryOn5xx(3).cache(60).execute(). (4) Next.js: API route builders - routeBuilder.method('POST').validate(schema).middleware(auth).handler(async (req) => {...}). Common pitfalls: (1) Forgetting return this: Method without return this breaks chain (compile error). (2) Mutable state in builder: Builders should be immutable (return new instance per method) for predictable chaining, not mutate internal state. Pattern: class ImmutableBuilder { private constructor(private state: State) {} withValue(v: string): ImmutableBuilder { return new ImmutableBuilder({ ...this.state, value: v }); } }. (3) Build method not final: build() should return final result, not another builder (prevents accidental continued chaining). Testing strategies: Use type-level tests with Expect type from @type-challenges/utils to verify builder enforces constraints - type test = Expect<Equal<ReturnType, 'Missing method'>> ensures send() without method() fails compilation. Best practices (2025): (1) Use polymorphic this for simple chaining (<10 methods, no required method enforcement). (2) Use state-tracking conditional types for complex builders with required methods (3-5 critical methods validated). (3) Use separate interfaces per state for large builders (>20 methods, performance-critical). (4) Combine with branded types for validated values (builder.email(brandedEmail) requires valid email, not raw string). (5) Add JSDoc to builder methods for better IDE hints alongside type safety.

Project references (tsconfig.json 'references' field) split large codebases into smaller, independently compilable projects. Setup: (1) Create separate tsconfig.json per package with 'composite: true', (2) Reference dependencies via 'references' array, (3) Use 'tsc --build' for incremental builds. Benefits: (1) 30-70% faster builds via parallel compilation, (2) Incremental rebuilds only for changed projects, (3) Better IDE performance (only loads relevant projects), (4) Enforces dependency graph (prevents circular dependencies). Best practices: (1) Align with package boundaries, (2) Use 'declarationMap: true' for jump-to-definition across projects, (3) Build with 'tsc -b --watch' for dev, (4) Use project references even for frontend/backend split. Gotcha: requires 'outDir' and '.d.ts' emission. Tools: turbo, nx leverage project references for optimal caching. Critical for monorepos >50k LOC.

Const type parameters (TypeScript 5.0+): Use const modifier on generic type parameters to infer most specific literal types instead of widened base types, preserving exact values at compile time for maximum type safety. Syntax: function identity(value: T): T { return value; } - const before T instructs compiler to infer narrowest possible type. Widening problem (pre-5.0): Without const, TypeScript widens literal types to base types for usability. Example: function process(arr: T[]): T[] { return arr; }; const nums = process([1, 2, 3]) infers T as number, losing literal values (nums: number[], not readonly [1, 2, 3]). Similarly, const obj = identity({ timeout: 5000 }) widens timeout to number, not literal 5000. With const type parameters: function asConst(value: T): T { return value; }; const nums = asConst([1, 2, 3]) infers readonly [1, 2, 3] (tuple with exact literals), const obj = asConst({ timeout: 5000 }) infers { readonly timeout: 5000 } (literal 5000, not number). Key differences: (1) Arrays become tuples: [1, 2] inferred as readonly [1, 2] instead of number[], preserving length and literal values. (2) Object properties become literals: { timeout: 5000 } inferred as { readonly timeout: 5000 } instead of { timeout: number }. (3) Strings remain literals: 'admin' stays 'admin', not widened to string. (4) Readonly modifier applied: All inferred types become readonly to prevent mutation (type safety guarantee). Production use cases: (1) Configuration objects: const config = defineConfig({ port: 3000, host: 'localhost', features: ['auth', 'logging'] }); type Port = typeof config.port (literal 3000, not number), type Features = typeof config.features[number] (literal union 'auth' | 'logging', not string). Enables exhaustive switch statements on feature flags. (2) Route definitions: const routes = createRoutes([{ path: '/users', method: 'GET' }, { path: '/posts', method: 'POST' }]); type Paths = typeof routes[number]['path'] extracts literal union '/users' | '/posts' for type-safe routing. React Router, Express route builders benefit. (3) Enum alternatives: const Status = asConst({ Pending: 'pending', Active: 'active', Completed: 'completed' }); type StatusValue = typeof Status[keyof typeof Status] creates union 'pending' | 'active' | 'completed' without enum overhead. (4) Translation keys: const translations = defineTranslations({ en: { greeting: 'Hello' }, es: { greeting: 'Hola' } }); type TranslationKey = keyof typeof translations.en ensures i18n keys type-safe ('greeting', not any string). (5) API endpoint builders: const endpoints = defineEndpoints(['/api/users', '/api/posts', '/api/comments']); type Endpoint = typeof endpoints[number] creates literal union for type-safe fetch wrapper. Combining with satisfies operator: const config = { port: 3000, host: 'localhost' } as const satisfies ServerConfig validates config matches ServerConfig interface while preserving literal types (port: 3000, not number). Best of both worlds: validation + specificity. Alternative syntax: const config = defineConfig({ ... }) satisfies ServerConfig. Exhaustiveness checking: Literal unions enable exhaustive switch statements with compiler verification. Example: type Feature = typeof config.features[number]; function handleFeature(f: Feature): void { switch (f) { case 'auth': ...; case 'logging': ...; } } - adding new feature to config forces updating switch (no default case needed). Framework integration: (1) React: const buttonVariants = asConst(['primary', 'secondary', 'danger']); type Variant = typeof buttonVariants[number]; interface ButtonProps { variant: Variant; } ensures only valid variants accepted. (2) Vue: defineProps() in Vue 3.3+ preserves literal types for prop validators. (3) Next.js: const locales = asConst(['en', 'es', 'fr']); export type Locale = typeof locales[number] for type-safe i18n routing. (4) tRPC: const procedures = asProcedures({ getUser: ..., createPost: ... }); type Procedures = keyof typeof procedures ensures client calls match server procedures. Performance: (1) Runtime: Zero overhead - const type parameters are compile-time only, no generated JavaScript code. (2) Compile-time: Minimal impact (<5% slower) for most codebases, const inference cached per function call. (3) IDE: Improves autocomplete precision (shows exact literals, not base types), better error messages (expected 'admin', got 'admn'). Comparison with as const assertion: (1) as const: Applied to value - const arr = [1, 2] as const (readonly [1, 2]). Requires user to add assertion at call site. (2) const type parameter: Applied to function - function f(v: T) infers const automatically. Library authors add once, all consumers benefit without manual assertions. Use const type parameters for public APIs, as const for internal code. Limitations: (1) Readonly enforcement: Inferred types become readonly - mutation attempts fail. Workaround: Cast to mutable type if mutation needed (discouraged). (2) Breaking changes: Upgrading function to use const type parameter can break consumers expecting widened types. Migration: Add overload with non-const version for backwards compatibility. (3) Complex inference: Deeply nested structures (10+ levels) with const can slow type-checking 10-20%. Limit const to top 2-3 levels. Best practices (2025): (1) Use const type parameters for public API functions accepting configuration/data that should preserve literals. (2) Combine with satisfies for validation + specificity. (3) Document const behavior in JSDoc (users may not expect readonly). (4) Provide non-const overload for mutation-heavy use cases. (5) Use with builder patterns to preserve literal types through method chains. Migration path: For existing codebases, gradually add const to generic functions where literal preservation adds value (config functions, route builders, translation keys), measure compile-time impact with --extendedDiagnostics.

'satisfies' operator (TypeScript 4.9+) validates a value against a type without widening or changing the inferred type. Syntax: const value = expression satisfies Type. Difference from 'as': (1) 'satisfies' preserves narrow type while validating, (2) 'as' overrides inferred type (unsafe). Example: const colors = { red: [255, 0, 0], blue: '#0000FF' } satisfies Record<string, string | number[]>. This validates structure but preserves literal types for red/blue. With 'as Record<...>', you'd lose literal property names. Use cases: (1) Config objects - validate shape but keep literals, (2) Discriminated unions - ensure object matches union while preserving exact variant, (3) API responses - validate schema while inferring exact type. Benefits: type safety without sacrificing inference. Combine with const assertions: value satisfies Type as const. More type-safe than type assertions; prefer 'satisfies' over 'as' when possible.

Brand types (nominal typing pattern): Add compile-time distinction to structurally identical types by creating unique type tags, preventing accidental mixing of values with same runtime representation but different semantic meaning. TypeScript's structural typing problem: Type compatibility based on shape, not name - type UserId = string; type OrderId = string; function getUser(id: UserId) {...} accepts OrderId (both strings), causing bugs when IDs mixed. Basic brand pattern: type Brand<K, T> = K & { __brand: T }; type UserId = Brand<string, 'UserId'>; type OrderId = Brand<string, 'OrderId'>. Intersection with phantom property (_brand: T) creates distinct types - UserId incompatible with OrderId despite both being strings. Phantom property never exists at runtime (TypeScript erases types), only compile-time distinction. Creating branded values: (1) Type assertion (unsafe): const userId = 'user_123' as UserId - bypasses validation, only type-level distinction. (2) Smart constructor (safe): function createUserId(id: string): UserId { if (!id.startsWith('user')) throw new Error('Invalid user ID'); return id as UserId; } - validates before branding, ensures only valid IDs branded. Advanced validation pattern: type ValidatedBrand<K, T, V extends (value: K) => boolean> = K & { __brand: T; _validator: V }; function brand<K, T, V extends (value: K) => boolean>(value: K, validator: V): ValidatedBrand<K, T, V> { if (!validator(value)) throw new Error('Validation failed'); return value as any; } const userId = brand('user_123', (id) => id.startsWith('user')) ensures compile-time distinction + runtime validation. Production use cases: (1) Preventing ID confusion: type UserId = Brand<string, 'UserId'>; type ProductId = Brand<string, 'ProductId'>; function getUser(id: UserId) {...} rejects ProductId, preventing cross-entity ID bugs (user ID passed to product lookup). (2) Validated strings: type Email = Brand<string, 'Email'>; type URL = Brand<string, 'URL'>; const createEmail = (s: string): Email => { if (!/^[^@]+@[^@]+$/.test(s)) throw new Error('Invalid email'); return s as Email; } - ensures only validated emails accepted where Email type required. (3) Units of measurement: type Meters = Brand<number, 'Meters'>; type Feet = Brand<number, 'Feet'>; const toMeters = (feet: Feet): Meters => (feet * 0.3048) as Meters - prevents accidental mixing of imperial/metric (can't add Meters + Feet without conversion). (4) Currency: type USD = Brand<number, 'USD'>; type EUR = Brand<number, 'EUR'>; prevents adding USD + EUR without explicit exchange rate conversion. (5) Sensitive data: type SensitizedString = Brand<string, 'Sensitive'>; type PlainString = string; const encrypt = (plain: PlainString): SensitizedString => ... ensures sensitive strings never logged/displayed without sanitization. (6) File paths: type AbsolutePath = Brand<string, 'AbsolutePath'>; type RelativePath = Brand<string, 'RelativePath'>; prevents mixing path types in filesystem operations. Benefits: (1) Compile-time safety: TypeScript catches mismatched types at build time (UserId vs OrderId errors before deployment). (2) Zero runtime cost: Brands erased during compilation, no JavaScript overhead (no classes, no runtime checks unless validation added). (3) Self-documenting: Function signature function getUser(id: UserId) clearly indicates expected ID type, better than function getUser(id: string). (4) Refactoring safety: Renaming type UserIdentifier = Brand<string, 'UserIdentifier'> updates all usages, compiler catches missed spots. Drawbacks: (1) Requires explicit construction: Users must call createUserId() or cast, can't use raw strings directly - more verbose. Mitigation: Provide convenience constructors, export validation functions. (2) Type assertion needed: Smart constructors still require unsafe cast (return id as UserId), TypeScript can't verify brand validity. Mitigation: Encapsulate casts in trusted factory functions, document validation guarantees. (3) Interop with unbranded code: Third-party libraries return string, must cast to UserId - unsafe. Mitigation: Create adapter functions at API boundaries. (4) Serialization issues: JSON.stringify strips types, deserialized values lose brands - need revalidation. Mitigation: Use Zod/io-ts schema validation after deserialization. Alternative: Opaque types via classes: class UserId { private brand!: void; constructor(public readonly value: string) { if (!value.startsWith('user')) throw new Error('Invalid'); } }. Pros: True runtime enforcement, no type assertions, safer. Cons: Runtime overhead (class instances), more verbose (new UserId('...')), serialization complex. Use classes for mission-critical domains (financial amounts, cryptographic keys), branded types for performance-sensitive code. Framework integration: (1) React: type ComponentId = Brand<string, 'ComponentId'>; ensures component keys unique. (2) Next.js: type PageSlug = Brand<string, 'PageSlug'>; validates URL slugs at routing layer. (3) tRPC: Branded types in procedure inputs ensure type-safe RPC calls (clientId: ClientId, not string). (4) Prisma: Brand database ID types (type UserPrismaId = Brand<string, 'UserPrismaId'>) to distinguish from application IDs. Combining with Zod validation: const UserIdSchema = z.string().refine(s => s.startsWith('user')).transform(s => s as UserId); combines runtime validation with compile-time branding. Testing strategies: Use type-level tests to verify brands incompatible - type test1 = Expect<Equal<UserId, OrderId>> should fail compilation. Test smart constructors throw on invalid input. Best practices (2025): (1) Use smart constructors for all brand creation (never expose raw type assertions). (2) Export constructor functions alongside branded types. (3) Document validation rules in JSDoc for discoverability. (4) Use brands for domain-critical distinctions (IDs, currencies, units), not trivial cases (FirstName vs LastName - overkill). (5) Combine with readonly for immutable branded values (type UserId = Brand<Readonly, 'UserId'>). (6) Use discriminated unions instead of brands when runtime tag available (type Event = { type: 'click'; ... } | { type: 'submit'; ... } better than branded Event types). Migration path: Gradually introduce brands to high-risk areas (ID parameters causing production bugs), expand to other domains as value proven. Use codemod to convert function signatures from string to UserId, find unsafe casts with linter.

Template literal types allow creating dynamic types using string literals with ${T} syntax, enabling powerful type-level string manipulation. Use cases: API route typing (e.g., /api/${Endpoint}), event name patterns, CSS class combinations. They enable extracting patterns from strings with 'infer' in TypeScript 5.x (e.g., extracting path parameters from URL templates). Prefer template literals when you need pattern matching or string transformations at type level; use string unions for fixed, enumerable values. Example: type EventName<T> = on${Capitalize}Change; type UserEvent = EventName<'user'> // 'onUserChange'. Combines well with conditional types for sophisticated abstractions.

Conditional types in TypeScript use T extends U ? X : Y syntax. Distributive behavior occurs when T is a naked type parameter (not wrapped in array/tuple), causing the type to distribute over union members. Example: type ToArray<T> = T extends any ? T[] : never; type Result = ToArray<string | number> yields string[] | number[] (distributed). Non-distributive wrapping: type ToArray<T> = [T] extends [any] ? T[] : never; type Result = ToArray<string | number> yields (string | number)[]. Use distributive for per-member transformation (filtering union types), non-distributive for whole-union operations. Critical for building utility types like Exclude, Extract, NonNullable. Performance note: complex conditional types can slow type-checking; prefer simpler mapped types when possible.

Mapped types with key remapping (TypeScript 4.1+) use 'as' clause to transform property keys: type Getters<T> = { [K in keyof T as get${Capitalize<string & K>}]: () => T[K] }. This creates getter methods from properties. Filter properties using never: type NonFunctionProps<T> = { [K in keyof T as T[K] extends Function ? never : K]: T[K] } removes function properties. Combine with template literals for sophisticated transformations. Use cases: creating DTOs from entities, event handler types from event names, API client types from OpenAPI specs. Performance: mapped types are compile-time only, zero runtime cost. Can combine with conditional types and recursive types for deep transformations. Prefer interfaces when possible for better editor performance.

Type inference vs explicit annotations (2025 performance analysis): TypeScript's type-checking performance is complex - both excessive inference and over-annotation cause slowdowns. Inference overhead: Compiler walks entire expression trees to infer types - lightweight for simple assignments (const x = 5), expensive for complex nested structures (deep object literals, generic chaining, conditional types). Annotation benefits: (1) Return type annotations: Save 20-40% compile time for complex functions by caching computed return type, preventing re-inference on every call. Critical for recursive/generic functions where inference requires multiple passes. (2) Named types: interface/type aliases are stored as type references in declaration files (compact), anonymous object types expand inline (bloat) - 50-70% smaller .d.ts files with named types. (3) Parameter types: Explicit types enable faster overload resolution and better error messages (precise source location vs generic 'type mismatch'). When to infer: (1) Local variables (const user = await getUser() - obvious from initializer), (2) Arrow function parameters with strong context (array.map(item => item.id) - item type from array), (3) Generic arguments when obvious (new Map<string, number>() vs new Map() with string/number values). When to annotate explicitly: (1) Public API functions: Always annotate parameters and return types - forms contract, improves intellisense, prevents breaking changes. (2) Complex return types: Functions returning unions, intersections, or conditional types - annotation prevents multi-second inference. (3) Library exports: All exported functions, classes, types must be explicit for .d.ts generation. (4) Large codebases (>100K lines): Explicit annotations reduce IDE memory usage (20-30% lower in VS Code with full annotations), faster hover tooltips, quicker autocomplete. Performance benchmarks (2025): Projects with explicit return types on all functions: 30-50% faster --noEmit checks, 15-25% faster incremental builds with tsc --build. TypeScript 5.x improvements: (1) Cached inference (TS 5.0+): Compiler caches inferred types across files, reducing redundant computation by 40%. (2) Lazy type evaluation: Defers complex type resolution until needed (hovers, errors), improving responsiveness. (3) Improved narrowing: Control flow analysis 60% faster than TS 4.x. Measurement tools: Use --extendedDiagnostics flag to see type-checking time per file, --generateTrace for flame graphs identifying slow types. Best practices (2025): (1) Annotate all function signatures in src/ (implementations), infer within function bodies. (2) Use named types for any structure used >3 times (avoid type duplication). (3) Avoid inline object types in function parameters: Bad: function process(config: { timeout: number; retries: number }) - creates new type per call site. Good: type Config = { timeout: number; retries: number }; function process(config: Config). (4) Use const assertions for literals instead of explicit types: const routes = ['/users', '/posts'] as const (infers tuple with literals) vs const routes: string[] = ['/users', '/posts'] (loses literal types). (5) Combine with strict mode flags: --strict --skipLibCheck --noUncheckedIndexedAccess for maximum type safety with minimal overhead. Framework-specific: React: annotate component props, infer state from useState. Vue: annotate defineProps, infer emits. Angular: explicit types for services, infer in templates. Next.js: annotate API routes, page props, infer client components. Tooling integration: ESLint @typescript-eslint/explicit-function-return-type rule enforces annotations, Prettier formats type annotations consistently, esbuild/Vite skip type-checking (use tsc --noEmit separately for validation).

'infer' declares type variables within conditional type extends clause, enabling type extraction. Syntax: type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never. Advanced patterns: (1) Extracting promise values: type Awaited<T> = T extends Promise<infer U> ? U : T, (2) Extracting array elements: type ElementType<T> = T extends (infer U)[] ? U : never, (3) Multiple infers for function params: type FirstArg<T> = T extends (arg1: infer A, ...rest: any[]) => any ? A : never. TypeScript 5.x enhanced infer in template literals: type ExtractRouteParams<T> = T extends '/${infer Param}/${infer Rest}' ? Param | ExtractRouteParams<'/${Rest}'> : never. Use for: building type-safe APIs, extracting generic parameters, creating utility types. Can combine with distributive conditional types for powerful abstractions.

Interface vs type performance (2025 analysis): TypeScript compiler optimizes interfaces and type aliases differently, with measurable performance implications in large codebases. Performance differences: (1) Type-checking speed: Interfaces use nominal identity for type comparisons internally (cached by name), while type aliases require full structural comparison every time. Benchmarks show 15-30% faster type-checking for interface-heavy codebases (>50K types). (2) Error messages: Interfaces display as their declared name in errors (interface User vs { name: string; age: number }), reducing error message verbosity by 50-80% and improving developer comprehension. (3) IDE autocomplete: Interfaces provide 20-40% faster intellisense in VS Code/WebStorm for large projects due to pre-computed type caches. (4) Declaration file size: Interfaces are more compact in .d.ts files (referenced by name), type aliases expand inline (especially with unions/intersections), causing 30-60% larger declaration files. Declaration merging (critical feature): Interfaces support merging multiple declarations into single type - TypeScript combines all interface declarations with same name in same scope. Use cases for merging: (1) Third-party augmentation: Extend global types without modifying original - Window interface augmentation for custom globals (declare global { interface Window { myAPI: MyAPI; } }), Express Request interface for custom properties (declare module 'express' { interface Request { user?: User; } }). (2) Plugin architectures: Each plugin adds methods to shared interface, automatically available to all consumers. (3) Incremental API design: Split large interfaces across files for maintainability, compiler merges at runtime. (4) Backwards compatibility: Add new properties without breaking existing declarations. Type aliases cannot merge - redeclaration causes error (Duplicate identifier). When to use interface: (1) Object shapes: Plain data structures, POJOs, DTO types. (2) Class contracts: Implementing classes, ensuring class structure. (3) Public APIs: Library exports, SDK types (better error messages for consumers). (4) Extensible types: Types users might augment (plugin APIs, global types). (5) Performance-critical codebases: Large monorepos (>100K LOC) where type-checking speed matters. When to use type: (1) Unions: type Status = 'pending' | 'active' | 'completed' (interfaces can't represent unions). (2) Intersections: type Admin = User & Permissions (combine types). (3) Mapped types: type Readonly = { readonly [K in keyof T]: T[K] } (advanced transformations). (4) Tuple types: type Point = [number, number] (fixed-length arrays with heterogeneous types). (5) Utility types: Pick, Omit, Partial, Required (conditional logic). (6) Primitive aliases: type ID = string | number (semantic meaning). (7) Template literal types: type EventName = on${Capitalize<string>}Change. Hybrid approach (2025 best practice): Use interface for object definitions (data models, API responses, component props), type for everything else (unions, utilities, complex transformations). Performance benchmarks (large projects >500K LOC): Interface-first approach: 25-35% faster type-checking, 40-50% smaller .d.ts files, 20-30% lower IDE memory usage. Framework-specific conventions: React: interface for component props (interface ButtonProps), type for state/context shapes. Vue: interface for defineProps schema, type for emits. Angular: interface for services/models, type for route guards. Next.js: interface for page props, type for API route handlers. Tooling recommendations: ESLint @typescript-eslint/consistent-type-definitions rule enforces consistent choice (interface or type), configure based on project size (interface for large projects, flexible for small). Migration strategy: For large codebases converting type to interface for performance: Use ts-migrate or jscodeshift for automated refactoring, preserve type for unions/intersections/utilities, measure type-checking improvement with --extendedDiagnostics before/after. TypeScript 5.x improvements: Better caching for both interfaces and types, but interface performance advantage remains for object shapes (compiler optimizations prioritize interface lookup paths).

Recursive conditional types (2025 comprehensive guide): Enable powerful deep type transformations by referencing themselves within type definition, creating self-referential type logic for nested structures. Basic mechanics: Type definition contains conditional type (T extends U ? X : Y) where X or Y references the type being defined, creating recursion. Example: type DeepReadonly = { readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K] } traverses object tree, applying readonly to every nested property. Common patterns (2025): (1) DeepPartial: type DeepPartial = { [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K] } - makes all nested properties optional for partial updates. (2) DeepRequired: type DeepRequired = { [K in keyof T]-?: T[K] extends object ? DeepRequired<T[K]> : T[K] } - removes optional modifiers recursively. (3) DeepPick/DeepOmit: Recursively select/exclude properties from nested objects. (4) JSON validation: type JSONValue = string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue } - ensures type represents valid JSON. (5) Path extraction: type Paths = T extends object ? { [K in keyof T]: K extends string ? K | ${K}.${Paths<T[K]>} : never }[keyof T] : never - generates all valid property paths ('user.address.city'). Limitations and errors (critical): (1) Recursion depth limit (~45-50 levels in TS 5.x): Compiler caps instantiation depth to prevent infinite loops. Exceeding limit produces 'Type instantiation is excessively deep and possibly infinite' error. Real-world impact: 50-level limit sufficient for most data structures (JSON APIs typically <20 levels deep), but fails for pathological cases (circular references, deeply nested configs). (2) Performance degradation: Each recursion level adds exponential type-checking overhead - 10-level recursion: 50-100ms type-check, 30-level: 2-5 seconds, 45-level: 20+ seconds. Large recursive types slow IDE intellisense (autocomplete freezes, hover delays). (3) Circular references: Cannot type circular structures (type Tree = { value: number; children: Tree[] }) without recursion limit error. Workaround: use any or unknown for circular parts. (4) Union distribution: Recursive types with unions distribute over each member, creating combinatorial explosion. Example: DeepPartial<A | B> expands to DeepPartial | DeepPartial, doubling type size per union level. Workarounds and optimizations: (1) Tail recursion (TS 4.5+): Compiler optimizes tail-recursive patterns (recursion as final operation) by caching intermediate results. Pattern: type DeepReadonly = T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T (conditional at top level, not inside mapped type). (2) Intermediate type aliases: Break deep recursion into smaller steps - type Level1 = {...}; type Level2 = Level1<Level1>; type Level4 = Level2<Level2> - reduces instantiation depth by pre-computing levels. (3) Depth limiting: Add depth counter parameter to prevent runaway recursion - type DeepReadonly<T, Depth extends number = 5> = Depth extends 0 ? T : { readonly [K in keyof T]: DeepReadonly<T[K], Prev> } (requires Prev utility to decrement). (4) Lazy evaluation: Use conditional types to defer recursion - type Lazy = T extends infer U ? U : never wraps type in conditional, delaying evaluation. Production use cases: (1) API response validation: Ensure deeply nested API responses match schema without manual type annotations. (2) Immutability enforcement: DeepReadonly for Redux state types, preventing accidental mutations 10 levels deep. (3) Configuration objects: Type-safe app configs with nested sections (database.pool.max, logging.level.console). (4) Form validation: Type paths for nested form fields (formik/react-hook-form field names). TypeScript version improvements: (1) TS 4.5: Tail-call optimization reduces recursion overhead 40-60%, better error messages showing recursion path. (2) TS 5.0: Cached recursive type instantiations (same type + same args = cached result), 30-50% faster for repeated recursions. (3) TS 5.3: Improved union distribution handling, better performance for recursive conditional types over unions. Alternatives for complex cases: (1) Runtime validation libraries: Zod (z.object({ ... }).deepPartial()), io-ts, Yup - provide runtime type safety for deeply nested structures where compile-time types hit limits. (2) Code generation: Use tools like quicktype or json-schema-to-typescript to generate types from JSON schemas, avoiding manual recursive types. (3) Type narrowing: Use type guards (isObject, hasProperty) for runtime checks instead of deep compile-time types. Best practices (2025): (1) Limit recursion to <20 levels for production code (better performance, clearer errors). (2) Combine with distributive conditional types for union handling. (3) Add depth parameter for safety-critical recursive types. (4) Test recursive types with deeply nested fixtures to catch limit errors early. (5) Use --extendedDiagnostics to measure type-checking performance impact.