--- name: typescript-master description: TypeScript language expert specializing in type system, generics, conditional types, and advanced patterns. Use when writing complex types, debugging type errors, or designing type-safe APIs. --- # TypeScript Language Expert Expert assistant for TypeScript type system mastery including generics, conditional types, mapped types, type inference, and advanced patterns. ## How It Works 1. Analyzes TypeScript code or type requirements 2. Designs type-safe solutions 3. Provides solutions with minimal type annotations (prefer inference) 4. Uses `unknown` over `any` 5. Leverages discriminated unions for safety ## Usage ### Run Type Check ```bash bash \/mnt\/skills\/user\/typescript-master\/scripts\/type-check.sh [project-dir] [strict-mode] ``` **Arguments:** - `project-dir` - Project directory (default: current directory) - `strict-mode` - Enable strict checks: true\/false (default: true) **Examples:** ```bash bash \/mnt\/skills\/user\/typescript-master\/scripts\/type-check.sh bash \/mnt\/skills\/user\/typescript-master\/scripts\/type-check.sh .\/my-project bash \/mnt\/skills\/user\/typescript-master\/scripts\/type-check.sh .\/my-project false ``` **Checks:** - TypeScript compilation (noEmit) - Strict type checking - Unused variables\/imports - tsconfig recommendations ## Documentation Resources **Official Documentation:** - TypeScript Handbook: `https:\/\/www.typescriptlang.org\/docs\/handbook\/` - Type Challenges: `https:\/\/github.com\/type-challenges\/type-challenges` ## Type System Fundamentals ### Utility Types ```typescript \/\/ Built-in utilities type Partial = { [P in keyof T]?: T[P] }; type Required = { [P in keyof T]-?: T[P] }; type Readonly = { readonly [P in keyof T]: T[P] }; type Pick = { [P in K]: T[P] }; type Omit = Pick>; type Record = { [P in K]: T }; ``` ### Custom Utility Types ```typescript \/\/ Deep Partial type DeepPartial = { [P in keyof T]?: T[P] extends object ? DeepPartial : T[P]; }; \/\/ Strict Omit (only known keys) type StrictOmit = Pick>; \/\/ Make specific keys required type RequireKeys = T & Required>; \/\/ Nullable type Nullable = T | null; ``` ## Generics Patterns ### Constrained Generics ```typescript \/\/ Key constraint function getProperty(obj: T, key: K): T[K] { return obj[key]; } \/\/ Type constraint function merge(a: T, b: U): T & U { return { ...a, ...b }; } ``` ### Inference with infer ```typescript \/\/ Extract return type type ReturnType = T extends (...args: any[]) => infer R ? R : never; \/\/ Extract promise value type Awaited = T extends Promise ? Awaited : T; \/\/ Extract array element type ArrayElement = T extends (infer E)[] ? E : never; \/\/ Extract function parameters type Parameters = T extends (...args: infer P) => any ? P : never; ``` ## Conditional Types ### Basic Conditional ```typescript type IsString = T extends string ? true : false; type IsArray = T extends any[] ? true : false; ``` ### Distributive Conditional ```typescript \/\/ Distributes over union type ToArray = T extends any ? T[] : never; type Result = ToArray; \/\/ string[] | number[] \/\/ Prevent distribution type ToArrayNonDist = [T] extends [any] ? T[] : never; type Result2 = ToArrayNonDist; \/\/ (string | number)[] ``` ## Discriminated Unions ```typescript type Result = | { success: true; data: T } | { success: false; error: E }; function handleResult(result: Result): T | null { if (result.success) { return result.data; \/\/ TypeScript knows data exists } else { console.error(result.error); \/\/ TypeScript knows error exists return null; } } ``` ## Type Guards ```typescript \/\/ Custom type guard function isUser(obj: unknown): obj is User { return ( typeof obj === 'object' && obj !== null && 'id' in obj && 'name' in obj && typeof (obj as User).id === 'string' ); } \/\/ Assertion function function assertNonNull( value: T, message?: string ): asserts value is NonNullable { if (value === null || value === undefined) { throw new Error(message ?? 'Value is null or undefined'); } } ``` ## Template Literal Types ```typescript type EventName = 'click' | 'focus' | 'blur'; type Handler = `on${Capitalize}`; \/\/ "onClick" | "onFocus" | "onBlur" type PropKey = `get${Capitalize}` | `set${Capitalize}`; type NameProps = PropKey<'name'>; \/\/ "getName" | "setName" ``` ## Recommended tsconfig ```json { "compilerOptions": { "strict": true, "noUncheckedIndexedAccess": true, "exactOptionalPropertyTypes": true, "noImplicitReturns": true, "noFallthroughCasesInSwitch": true, "noPropertyAccessFromIndexSignature": true, "moduleResolution": "bundler", "verbatimModuleSyntax": true } } ``` ## Present Results to User When providing TypeScript solutions: - Prefer type inference over explicit annotations - Use `unknown` instead of `any` - Leverage discriminated unions - Provide type test examples - Note TypeScript version features (5.0+: const type parameters) ## Troubleshooting **"Type 'X' is not assignable to type 'Y'"** - Check for missing properties - Verify nullability handling - Look for literal vs widened types **"Property does not exist on type"** - Add type guard before access - Check if property is optional - Verify union type narrowing **"Excessive type complexity"** - Break into smaller types - Use intermediate type aliases - Consider simplifying generics