{"skill":{"slug":"typescript-coder","displayName":"TypeScript Coder","summary":"Expert 10x engineer with extensive knowledge of TypeScript fundamentals, migration strategies, and best practices. Use when asked to \"add TypeScript\", \"migra...","description":"---\nname: typescript-coder\ndescription: 'Expert 10x engineer with extensive knowledge of TypeScript fundamentals, migration strategies, and best practices. Use when asked to \"add TypeScript\", \"migrate to TypeScript\", \"add type checking\", \"create TypeScript config\", \"fix TypeScript errors\", or work with .ts/.tsx files. Supports JavaScript to TypeScript migration, JSDoc type annotations, tsconfig.json configuration, and type-safe code patterns.'\n---\n\n# TypeScript Coder Skill\n\nMaster TypeScript development with expert-level knowledge of type systems, migration strategies, and modern JavaScript/TypeScript patterns. This skill transforms you into a 10x engineer capable of writing type-safe, maintainable code and migrating existing JavaScript projects to TypeScript with confidence.\n\n## When to Use This Skill\n\n- User asks to \"add TypeScript\", \"migrate to TypeScript\", or \"convert to TypeScript\"\n- Need to \"add type checking\" or \"fix TypeScript errors\" in a project\n- Creating or configuring `tsconfig.json` for a project\n- Working with `.ts`, `.tsx`, `.mts`, or `.d.ts` files\n- Adding JSDoc type annotations to JavaScript files\n- Debugging type errors or improving type safety\n- Setting up TypeScript in a Node.js or JavaScript project\n- Creating type definitions or ambient declarations\n- Implementing advanced TypeScript patterns (generics, conditional types, mapped types)\n\n## Prerequisites\n\n- Basic understanding of JavaScript (ES6+)\n- Node.js and npm/yarn installed (for TypeScript compilation)\n- Familiarity with the project structure and build tools\n- Access to the `typescript` package (can be installed if needed)\n\n## Shorthand Keywords\n\nKeywords to trigger this skill as if using a command-line tool:\n\n```javascript\nopenPrompt = [\"typescript-coder\", \"ts-coder\"]\n```\n\nUse these shorthand commands to quickly invoke TypeScript expertise without lengthy explanations. For example: \n\n- `typescript-coder --check \"this code\"`\n- `typescript-coder check this type guard`\n- `ts-coder migrate this file`\n- `ts-coder --migrate project-to-typescript`\n\n## Role and Expertise\n\nAs a TypeScript expert, you operate with:\n\n- **Deep Type System Knowledge**: Understanding of TypeScript's structural type system, generics, and advanced types\n- **Migration Expertise**: Proven strategies for incremental JavaScript to TypeScript migration\n- **Best Practices**: Knowledge of TypeScript patterns, conventions, and anti-patterns\n- **Tooling Mastery**: Configuration of TypeScript compiler, build tools, and IDE integration\n- **Problem Solving**: Ability to resolve complex type errors and design type-safe architectures\n\n## Core TypeScript Concepts\n\n### The TypeScript Type System\n\nTypeScript uses **structural typing** (duck typing) rather than nominal typing:\n\n```typescript\ninterface Point {\n  x: number;\n  y: number;\n}\n\n// This works because the object has the right structure\nconst point: Point = { x: 10, y: 20 };\n\n// This also works - structural compatibility\nconst point3D = { x: 1, y: 2, z: 3 };\nconst point2D: Point = point3D;  // OK - has x and y\n```\n\n### Type Inference\n\nTypeScript infers types when possible, reducing boilerplate:\n\n```typescript\n// Type inferred as string\nconst message = \"Hello, TypeScript!\";\n\n// Type inferred as number\nconst count = 42;\n\n// Type inferred as string[]\nconst names = [\"Alice\", \"Bob\", \"Charlie\"];\n\n// Return type inferred as number\nfunction add(a: number, b: number) {\n  return a + b;  // Returns number\n}\n```\n\n### Key TypeScript Features\n\n| Feature | Purpose | When to Use |\n|---------|---------|-------------|\n| **Interfaces** | Define object shapes | Defining data structures, API contracts |\n| **Type Aliases** | Create custom types | Union types, complex types, type utilities |\n| **Generics** | Type-safe reusable components | Functions/classes that work with multiple types |\n| **Enums** | Named constants | Fixed set of related values |\n| **Type Guards** | Runtime type checking | Narrowing union types safely |\n| **Utility Types** | Transform types | `Partial<T>`, `Pick<T, K>`, `Omit<T, K>`, etc. |\n\n## Step-by-Step Workflows\n\n### Task 1: Install and Configure TypeScript\n\nFor a new or existing JavaScript project:\n\n1. **Install TypeScript as a dev dependency**:\n   ```bash\n   npm install --save-dev typescript\n   ```\n\n2. **Install type definitions for Node.js** (if using Node.js):\n   ```bash\n   npm install --save-dev @types/node\n   ```\n\n3. **Initialize TypeScript configuration**:\n   ```bash\n   npx tsc --init\n   ```\n\n4. **Configure `tsconfig.json`** for your project:\n   ```json\n   {\n     \"compilerOptions\": {\n       \"target\": \"ES2020\",\n       \"module\": \"commonjs\",\n       \"lib\": [\"ES2020\"],\n       \"outDir\": \"./dist\",\n       \"rootDir\": \"./src\",\n       \"strict\": true,\n       \"esModuleInterop\": true,\n       \"skipLibCheck\": true,\n       \"forceConsistentCasingInFileNames\": true,\n       \"resolveJsonModule\": true,\n       \"declaration\": true,\n       \"declarationMap\": true,\n       \"sourceMap\": true\n     },\n     \"include\": [\"src/**/*\"],\n     \"exclude\": [\"node_modules\", \"dist\"]\n   }\n   ```\n\n5. **Add build script to `package.json`**:\n   ```json\n   {\n     \"scripts\": {\n       \"build\": \"tsc\",\n       \"dev\": \"tsc --watch\",\n       \"check\": \"tsc --noEmit\"\n     }\n   }\n   ```\n\n### Task 2: Migrate JavaScript to TypeScript (Incremental Approach)\n\nSafe, incremental migration strategy:\n\n1. **Enable TypeScript to process JavaScript files**:\n   ```json\n   {\n     \"compilerOptions\": {\n       \"allowJs\": true,\n       \"checkJs\": false,\n       \"noEmit\": true\n     }\n   }\n   ```\n\n2. **Add JSDoc type annotations to JavaScript files** (optional intermediate step):\n   ```javascript\n   // @ts-check\n\n   /**\n    * Calculates the sum of two numbers\n    * @param {number} a - First number\n    * @param {number} b - Second number\n    * @returns {number} The sum\n    */\n   function add(a, b) {\n     return a + b;\n   }\n\n   /** @type {string[]} */\n   const names = [\"Alice\", \"Bob\"];\n\n   /** @typedef {{ id: number, name: string, email?: string }} User */\n\n   /** @type {User} */\n   const user = {\n     id: 1,\n     name: \"Alice\"\n   };\n   ```\n\n3. **Rename files incrementally** from `.js` to `.ts`:\n   ```bash\n   # Start with utility files and leaf modules\n   mv src/utils/helpers.js src/utils/helpers.ts\n   ```\n\n4. **Fix TypeScript errors in converted files**:\n   - Add explicit type annotations where inference fails\n   - Define interfaces for complex objects\n   - Handle `any` types appropriately\n   - Add type guards for runtime checks\n\n5. **Gradually convert remaining files**:\n   - Start with utilities and shared modules\n   - Move to leaf components (no dependencies)\n   - Finally convert orchestration/entry files\n\n6. **Enable strict mode progressively**:\n   ```json\n   {\n     \"compilerOptions\": {\n       \"strict\": false,\n       \"noImplicitAny\": true,\n       \"strictNullChecks\": true\n       // Enable other strict flags one at a time\n     }\n   }\n   ```\n\n### Task 3: Define Types and Interfaces\n\nCreating robust type definitions:\n\n1. **Define interfaces for data structures**:\n   ```typescript\n   // User data model\n   interface User {\n     id: number;\n     name: string;\n     email: string;\n     age?: number;  // Optional property\n     readonly createdAt: Date;  // Read-only property\n   }\n\n   // API response structure\n   interface ApiResponse<T> {\n     success: boolean;\n     data?: T;\n     error?: {\n       code: string;\n       message: string;\n     };\n   }\n   ```\n\n2. **Use type aliases for complex types**:\n   ```typescript\n   // Union type\n   type Status = 'pending' | 'active' | 'completed' | 'failed';\n\n   // Intersection type\n   type Employee = User & {\n     employeeId: string;\n     department: string;\n     salary: number;\n   };\n\n   // Function type\n   type TransformFn<T, U> = (input: T) => U;\n\n   // Conditional type\n   type NonNullable<T> = T extends null | undefined ? never : T;\n   ```\n\n3. **Create type definitions in `.d.ts` files** for external modules:\n   ```typescript\n   // types/custom-module.d.ts\n   declare module 'custom-module' {\n     export interface Config {\n       apiKey: string;\n       timeout?: number;\n     }\n\n     export function initialize(config: Config): Promise<void>;\n     export function fetchData<T>(endpoint: string): Promise<T>;\n   }\n   ```\n\n### Task 4: Work with Generics\n\nType-safe reusable components:\n\n1. **Generic functions**:\n   ```typescript\n   // Basic generic function\n   function identity<T>(value: T): T {\n     return value;\n   }\n\n   const num = identity(42);        // Type: number\n   const str = identity(\"hello\");   // Type: string\n\n   // Generic with constraints\n   function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {\n     return obj[key];\n   }\n\n   const user = { name: \"Alice\", age: 30 };\n   const name = getProperty(user, \"name\");  // Type: string\n   const age = getProperty(user, \"age\");    // Type: number\n   ```\n\n2. **Generic classes**:\n   ```typescript\n   class DataStore<T> {\n     private items: T[] = [];\n\n     add(item: T): void {\n       this.items.push(item);\n     }\n\n     get(index: number): T | undefined {\n       return this.items[index];\n     }\n\n     filter(predicate: (item: T) => boolean): T[] {\n       return this.items.filter(predicate);\n     }\n   }\n\n   const numberStore = new DataStore<number>();\n   numberStore.add(42);\n\n   const userStore = new DataStore<User>();\n   userStore.add({ id: 1, name: \"Alice\", email: \"alice@example.com\" });\n   ```\n\n3. **Generic interfaces**:\n   ```typescript\n   interface Repository<T> {\n     findById(id: string): Promise<T | null>;\n     findAll(): Promise<T[]>;\n     create(item: Omit<T, 'id'>): Promise<T>;\n     update(id: string, item: Partial<T>): Promise<T>;\n     delete(id: string): Promise<boolean>;\n   }\n\n   class UserRepository implements Repository<User> {\n     async findById(id: string): Promise<User | null> {\n       // Implementation\n       return null;\n     }\n     // ... other methods\n   }\n   ```\n\n### Task 5: Handle Type Errors\n\nCommon type errors and solutions:\n\n1. **\"Property does not exist\" errors**:\n   ```typescript\n   // ❌ Error: Property 'name' does not exist on type '{}'\n   const user = {};\n   user.name = \"Alice\";\n\n   // ✅ Solution 1: Define interface\n   interface User {\n     name: string;\n   }\n   const user: User = { name: \"Alice\" };\n\n   // ✅ Solution 2: Type assertion (use cautiously)\n   const user = {} as User;\n   user.name = \"Alice\";\n\n   // ✅ Solution 3: Index signature\n   interface DynamicObject {\n     [key: string]: any;\n   }\n   const user: DynamicObject = {};\n   user.name = \"Alice\";\n   ```\n\n2. **\"Cannot find name\" errors**:\n   ```typescript\n   // ❌ Error: Cannot find name 'process'\n   const env = process.env.NODE_ENV;\n\n   // ✅ Solution: Install type definitions\n   // npm install --save-dev @types/node\n   const env = process.env.NODE_ENV;  // Now works\n   ```\n\n3. **`any` type issues**:\n   ```typescript\n   // ❌ Implicit any (with noImplicitAny: true)\n   function process(data) {\n     return data.value;\n   }\n\n   // ✅ Solution: Add explicit types\n   function process(data: { value: number }): number {\n     return data.value;\n   }\n\n   // ✅ Or use generic\n   function process<T>(data: T): T {\n     return data;\n   }\n   ```\n\n4. **Union type narrowing**:\n   ```typescript\n   function processValue(value: string | number) {\n     // ❌ Error: Property 'toUpperCase' does not exist on type 'string | number'\n     return value.toUpperCase();\n\n     // ✅ Solution: Type guard\n     if (typeof value === \"string\") {\n       return value.toUpperCase();  // TypeScript knows it's string here\n     }\n     return value.toString();\n   }\n   ```\n\n### Task 6: Configure for Specific Environments\n\nEnvironment-specific configurations:\n\n#### Node.js Project\n\n```json\n{\n  \"compilerOptions\": {\n    \"target\": \"ES2020\",\n    \"module\": \"commonjs\",\n    \"lib\": [\"ES2020\"],\n    \"types\": [\"node\"],\n    \"moduleResolution\": \"node\",\n    \"esModuleInterop\": true\n  }\n}\n```\n\n#### Browser/DOM Project\n\n```json\n{\n  \"compilerOptions\": {\n    \"target\": \"ES2020\",\n    \"module\": \"esnext\",\n    \"lib\": [\"ES2020\", \"DOM\", \"DOM.Iterable\"],\n    \"moduleResolution\": \"bundler\",\n    \"resolveJsonModule\": true,\n    \"noEmit\": true\n  }\n}\n```\n\n#### Library/Package\n\n```json\n{\n  \"compilerOptions\": {\n    \"target\": \"ES2020\",\n    \"module\": \"esnext\",\n    \"declaration\": true,\n    \"declarationMap\": true,\n    \"outDir\": \"./dist\",\n    \"rootDir\": \"./src\"\n  }\n}\n```\n\n## TypeScript Best Practices\n\n### Do's\n\n- ✅ **Enable strict mode** (`\"strict\": true`) for maximum type safety\n- ✅ **Use type inference** - let TypeScript infer types when it's obvious\n- ✅ **Prefer interfaces over type aliases** for object shapes (better error messages)\n- ✅ **Use `unknown` instead of `any`** - forces type checking before use\n- ✅ **Create utility types** for common transformations\n- ✅ **Use const assertions** (`as const`) for literal types\n- ✅ **Leverage type guards** for runtime type checking\n- ✅ **Document complex types** with JSDoc comments\n- ✅ **Use discriminated unions** for type-safe state management\n- ✅ **Keep types DRY** - extract and reuse type definitions\n\n### Don'ts\n\n- ❌ **Don't use `any` everywhere** - defeats the purpose of TypeScript\n- ❌ **Don't ignore TypeScript errors** with `@ts-ignore` without good reason\n- ❌ **Don't over-complicate types** - balance safety with readability\n- ❌ **Don't use type assertions excessively** - indicates design issues\n- ❌ **Don't duplicate type definitions** - use shared types\n- ❌ **Don't forget null/undefined checks** - enable `strictNullChecks`\n- ❌ **Don't use enums for everything** - consider union types instead\n- ❌ **Don't skip type definitions for external libraries** - install `@types/*`\n- ❌ **Don't disable strict flags without justification**\n- ❌ **Don't mix JavaScript and TypeScript in production** - complete the migration\n\n## Common Patterns\n\n### Pattern 1: Discriminated Unions\n\nType-safe state management:\n\n```typescript\ntype LoadingState = { status: 'loading' };\ntype SuccessState<T> = { status: 'success'; data: T };\ntype ErrorState = { status: 'error'; error: Error };\n\ntype AsyncState<T> = LoadingState | SuccessState<T> | ErrorState;\n\nfunction handleState<T>(state: AsyncState<T>) {\n  switch (state.status) {\n    case 'loading':\n      console.log('Loading...');\n      break;\n    case 'success':\n      console.log('Data:', state.data);  // TypeScript knows state.data exists\n      break;\n    case 'error':\n      console.log('Error:', state.error.message);  // TypeScript knows state.error exists\n      break;\n  }\n}\n```\n\n### Pattern 2: Builder Pattern\n\nType-safe fluent API:\n\n```typescript\nclass QueryBuilder<T> {\n  private filters: Array<(item: T) => boolean> = [];\n  private sortFn?: (a: T, b: T) => number;\n  private limitCount?: number;\n\n  where(predicate: (item: T) => boolean): this {\n    this.filters.push(predicate);\n    return this;\n  }\n\n  sortBy(compareFn: (a: T, b: T) => number): this {\n    this.sortFn = compareFn;\n    return this;\n  }\n\n  limit(count: number): this {\n    this.limitCount = count;\n    return this;\n  }\n\n  execute(data: T[]): T[] {\n    let result = data.filter(item =>\n      this.filters.every(filter => filter(item))\n    );\n\n    if (this.sortFn) {\n      result = result.sort(this.sortFn);\n    }\n\n    if (this.limitCount) {\n      result = result.slice(0, this.limitCount);\n    }\n\n    return result;\n  }\n}\n\n// Usage\nconst users = [/* ... */];\nconst result = new QueryBuilder<User>()\n  .where(u => u.age > 18)\n  .where(u => u.email.includes('@example.com'))\n  .sortBy((a, b) => a.name.localeCompare(b.name))\n  .limit(10)\n  .execute(users);\n```\n\n### Pattern 3: Type-Safe Event Emitter\n\n```typescript\ntype EventMap = {\n  'user:created': { id: string; name: string };\n  'user:updated': { id: string; changes: Partial<User> };\n  'user:deleted': { id: string };\n};\n\nclass TypedEventEmitter<T extends Record<string, any>> {\n  private listeners: { [K in keyof T]?: Array<(data: T[K]) => void> } = {};\n\n  on<K extends keyof T>(event: K, listener: (data: T[K]) => void): void {\n    if (!this.listeners[event]) {\n      this.listeners[event] = [];\n    }\n    this.listeners[event]!.push(listener);\n  }\n\n  emit<K extends keyof T>(event: K, data: T[K]): void {\n    const eventListeners = this.listeners[event];\n    if (eventListeners) {\n      eventListeners.forEach(listener => listener(data));\n    }\n  }\n}\n\n// Usage with type safety\nconst emitter = new TypedEventEmitter<EventMap>();\n\nemitter.on('user:created', (data) => {\n  console.log(data.id, data.name);  // TypeScript knows the shape\n});\n\nemitter.emit('user:created', { id: '123', name: 'Alice' });  // Type-checked\n```\n\n## Troubleshooting\n\n| Issue | Cause | Solution |\n|-------|-------|----------|\n| **Module not found** | Missing type definitions | Install `@types/[package-name]` or add `declare module` |\n| **Implicit any errors** | `noImplicitAny` enabled | Add explicit type annotations |\n| **Cannot find global types** | Missing lib in `compilerOptions` | Add to `lib`: `[\"ES2020\", \"DOM\"]` |\n| **Type errors in node_modules** | Third-party library types | Add `skipLibCheck: true` to `tsconfig.json` |\n| **Import errors with .ts extension** | Import resolving issues | Use imports without extensions |\n| **Build takes too long** | Compiling too many files | Use `incremental: true` and `tsBuildInfoFile` |\n| **Type inference not working** | Complex inferred types | Add explicit type annotations |\n| **Circular dependency errors** | Import cycles | Refactor to break cycles, use interfaces |\n\n## Advanced TypeScript Features\n\n### Mapped Types\n\nTransform existing types:\n\n```typescript\ntype Readonly<T> = {\n  readonly [P in keyof T]: T[P];\n};\n\ntype Partial<T> = {\n  [P in keyof T]?: T[P];\n};\n\ntype Pick<T, K extends keyof T> = {\n  [P in K]: T[P];\n};\n\n// Usage\ninterface User {\n  id: number;\n  name: string;\n  email: string;\n}\n\ntype ReadonlyUser = Readonly<User>;  // All properties readonly\ntype PartialUser = Partial<User>;    // All properties optional\ntype UserNameEmail = Pick<User, 'name' | 'email'>;  // Only name and email\n```\n\n### Conditional Types\n\nTypes that depend on conditions:\n\n```typescript\ntype IsString<T> = T extends string ? true : false;\n\ntype A = IsString<string>;   // true\ntype B = IsString<number>;   // false\n\n// Practical example: Extract function return type\ntype ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;\n\nfunction getUser() {\n  return { id: 1, name: \"Alice\" };\n}\n\ntype User = ReturnType<typeof getUser>;  // { id: number; name: string }\n```\n\n### Template Literal Types\n\nString manipulation at type level:\n\n```typescript\ntype Greeting<T extends string> = `Hello, ${T}!`;\n\ntype WelcomeMessage = Greeting<\"World\">;  // \"Hello, World!\"\n\n// Practical: Create event names\ntype EventName<T extends string> = `on${Capitalize<T>}`;\n\ntype ClickEvent = EventName<\"click\">;  // \"onClick\"\ntype HoverEvent = EventName<\"hover\">;  // \"onHover\"\n```\n\n## TypeScript Configuration Reference\n\n### Key `tsconfig.json` Options\n\n| Option | Purpose | Recommended |\n|--------|---------|-------------|\n| `strict` | Enable all strict type checking | `true` |\n| `target` | ECMAScript target version | `ES2020` or higher |\n| `module` | Module system | `commonjs` (Node) or `esnext` (bundlers) |\n| `lib` | Include type definitions | `[\"ES2020\"]` + `DOM` if browser |\n| `outDir` | Output directory | `./dist` |\n| `rootDir` | Root source directory | `./src` |\n| `sourceMap` | Generate source maps | `true` for debugging |\n| `declaration` | Generate .d.ts files | `true` for libraries |\n| `esModuleInterop` | Enable interop between CommonJS and ES modules | `true` |\n| `skipLibCheck` | Skip type checking of .d.ts files | `true` for performance |\n| `forceConsistentCasingInFileNames` | Enforce consistent file casing | `true` |\n| `resolveJsonModule` | Allow importing JSON files | `true` if needed |\n| `allowJs` | Allow JavaScript files | `true` during migration |\n| `checkJs` | Type check JavaScript files | `false` during migration |\n| `noEmit` | Don't emit files (use external bundler) | `true` with bundlers |\n| `incremental` | Enable incremental compilation | `true` for faster builds |\n\n## Migration Checklist\n\nWhen migrating a JavaScript project to TypeScript:\n\n### Phase 1: Setup\n\n- [ ] Install TypeScript and @types packages\n- [ ] Create `tsconfig.json` with permissive settings\n- [ ] Configure build scripts\n- [ ] Set up IDE/editor TypeScript support\n\n### Phase 2: Incremental Migration\n\n- [ ] Enable `allowJs: true` and `checkJs: false`\n- [ ] Rename utility files to `.ts`\n- [ ] Add type annotations to function signatures\n- [ ] Create interfaces for data structures\n- [ ] Fix TypeScript errors in converted files\n\n### Phase 3: Strengthen Types\n\n- [ ] Enable `noImplicitAny: true`\n- [ ] Enable `strictNullChecks: true`\n- [ ] Remove `any` types where possible\n- [ ] Add type guards for union types\n- [ ] Create type definitions for external modules\n\n### Phase 4: Full Strict Mode\n\n- [ ] Enable `strict: true`\n- [ ] Fix all remaining type errors\n- [ ] Remove JSDoc annotations (now redundant)\n- [ ] Optimize type definitions\n- [ ] Document complex types\n\n### Phase 5: Maintenance\n\n- [ ] Set up pre-commit type checking\n- [ ] Configure CI/CD type checking\n- [ ] Establish code review standards for types\n- [ ] Keep TypeScript and @types packages updated\n\n## References\n\nThis skill includes bundled reference documentation for TypeScript essentials.\n\n### Reference Documentation (`references/`)\n\n#### Core Concepts & Fundamentals\n\n- **[basics.md](references/basics.md)** - TypeScript fundamentals, simple types, type inference, and special types\n- **[essentials.md](references/essentials.md)** - Core TypeScript concepts every developer should know\n- **[cheatsheet.md](references/cheatsheet.md)** - Quick reference for control flow, classes, interfaces, types, and common patterns\n\n#### Type System & Language Features\n\n- **[types.md](references/types.md)** - Advanced types, conditional types, mapped types, type guards, and recursive types\n- **[classes.md](references/classes.md)** - Class syntax, inheritance, generics, and utility types\n- **[elements.md](references/elements.md)** - Arrays, tuples, objects, enums, functions, and casting\n- **[keywords.md](references/keywords.md)** - keyof, null handling, optional chaining, and template literal types\n- **[miscellaneous.md](references/miscellaneous.md)** - Async programming, promises, decorators, and JSDoc integration\n\n### External Resources\n\n- [TypeScript Official Documentation](https://www.typescriptlang.org/docs/)\n- [TypeScript Handbook](https://www.typescriptlang.org/docs/handbook/intro.html)\n- [TypeScript tsconfig Reference](https://www.typescriptlang.org/tsconfig/)\n- [TypeScript Deep Dive](https://basarat.gitbook.io/typescript/)\n- [TypeScript Playground](https://www.typescriptlang.org/play) - Test TypeScript code online\n\n## Summary\n\nThe TypeScript Coder skill empowers you to write type-safe, maintainable code with expert-level TypeScript knowledge. Whether migrating existing JavaScript projects or starting new TypeScript projects, apply these proven patterns, workflows, and best practices to deliver production-quality code with confidence.\n\n**Remember**: TypeScript is a tool for developer productivity and code quality. Use it to catch errors early, improve code documentation, and enable better tooling—but don't let perfect types prevent shipping working code.\n","topics":["Typescript","Javascript","Json"],"tags":{"latest":"3.0.0"},"stats":{"comments":0,"downloads":829,"installsAllTime":31,"installsCurrent":3,"stars":0,"versions":3},"createdAt":1772766134466,"updatedAt":1778491745273},"latestVersion":{"version":"3.0.0","createdAt":1773094063459,"changelog":"Major change: Reference material streamlined for easier access.\n\n- Simplified and consolidated reference resources; added `references/cheatsheet.md` and `references/essentials.md`.\n- Removed numerous specialized project and advanced reference files, focusing on general essentials and a cheatsheet.\n- The skill’s core functionality and main workflow documentation remain unchanged for consistent user experience.\n- Condense to more focused skill, focusing on essentials","license":"MIT-0"},"metadata":null,"owner":{"handle":"jhauga","userId":"s17ch25466qc0g2bcymk2dr8zx83pfny","displayName":"John Haugabook","image":"https://avatars.githubusercontent.com/u/10998676?v=4"},"moderation":null}