typescript-strict
Use when writing TypeScript with strict mode - covers type definitions, generics, and declaration files
When & Why to Use This Skill
This Claude skill provides a comprehensive framework for writing high-quality TypeScript in strict mode. It focuses on enhancing type safety and code robustness by implementing best practices for type definitions, advanced generics, and declaration files. By leveraging patterns like discriminated unions and strict null checks, it helps developers minimize runtime errors and maintain a clean, scalable codebase.
Use Cases
- Configuring tsconfig.json with strict flags to establish a high-standard development environment.
- Implementing complex data structures using discriminated unions and type guards for exhaustive type checking.
- Developing reusable and type-safe utility functions using constrained generics and conditional types.
- Authoring accurate declaration files (.d.ts) for external modules to improve IDE intellisense and type coverage.
- Refactoring legacy TypeScript code to eliminate implicit 'any' types and handle null/undefined values explicitly.
| name | typescript-strict |
|---|---|
| description | Use when writing TypeScript with strict mode - covers type definitions, generics, and declaration files |
TypeScript Strict Mode Best Practices
Quick Start
// Enable strict in tsconfig.json
{
"compilerOptions": {
"strict": true,
"noUncheckedIndexedAccess": true,
"exactOptionalPropertyTypes": true
}
}
Core Principles
- Strict null checks: Handle
undefinedandnullexplicitly - No implicit any: Always declare types, avoid
any - Readonly by default: Use
readonlyfor immutable data - Discriminated unions: Use type guards with tagged unions
Type Definition Patterns
AST Node Types
// Discriminated union for AST nodes
type Expr =
| { type: "NumberLiteral"; value: number }
| { type: "BinaryExpr"; op: string; left: Expr; right: Expr }
| { type: "Identifier"; name: string };
// Type guard
function isNumberLiteral(expr: Expr): expr is Extract<Expr, { type: "NumberLiteral" }> {
return expr.type === "NumberLiteral";
}
Generic Types
// Constrained generics
function map<T, U>(arr: readonly T[], fn: (item: T, index: number) => U): U[] {
return arr.map(fn);
}
// Conditional types
type Unwrap<T> = T extends Promise<infer U> ? U : T;
Declaration Files
// module.d.ts
declare module "lea-lang" {
export function run(code: string): unknown;
export function parse(code: string): Program;
}
Common Patterns
- Use
unknownoveranyfor safer type narrowing - Prefer
interfacefor extendable types,typefor unions - Use
as constfor literal types - Leverage
satisfiesfor type checking without widening
Reference Files
- references/generics.md - Advanced generic patterns
- references/type-guards.md - Type narrowing techniques