陌讯skills聚合平台

typescript-patterns

📁 oakoss/agent-skills 📅 8 days ago
18
总安装量
18
周安装量
#19776
全站排名
安装命令
npx skills add https://github.com/oakoss/agent-skills --skill typescript-patterns

Agent 安装分布

claude-code 17
opencode 16
github-copilot 16
codex 16
kimi-cli 16
gemini-cli 16

Skill 文档

TypeScript Patterns

Overview

Advanced TypeScript patterns that use the type system to prevent runtime errors. Focuses on strict mode TypeScript with patterns for type inference, narrowing, and compile-time validation. Not a beginner tutorial.

When to use: Building type-safe APIs, complex data transformations, library authoring, preventing runtime errors through types, working with strict mode flags.

When NOT to use: Learning TypeScript basics (primitives, interfaces, classes), JavaScript-to-TypeScript migration guidance, tooling setup, or build configuration.

Quick Reference

Pattern API Key Points
Utility types Pick<T, K>, Omit<T, K> Extract or exclude properties
Partial/Required Partial<T>, Required<T> Make properties optional or required
Record type Record<K, V> Object with known keys
Awaited type Awaited<T> Unwrap Promise return types
ReturnType/Parameters ReturnType<F>, Parameters<F> Extract function types
Generic constraints <T extends Type> Constrain generic parameters
Type inference type Inferred = typeof value Let TypeScript infer from values
Type guards typeof, instanceof, in Narrow types at runtime
Custom type guards (x): x is Type User-defined narrowing functions
Inferred predicates (x) => x !== null Auto-inferred type predicate filters
Discriminated unions Union with literal type property Exhaustive pattern matching
Conditional types T extends U ? X : Y Type-level conditionals
Mapped types { [K in keyof T]: T[K] } Transform all properties
Template literals `${A}-${B}` String literal type manipulation
Const assertions as const Narrowest possible literal types
Satisfies operator value satisfies Type Type check without widening
NoInfer utility NoInfer<T> Prevent inference from a position
Const type params <const T extends Type> Narrow inference without as const
Inline type imports import { type User } Import types explicitly
Module augmentation declare module 'lib' { ... } Extend third-party types
Assertion functions function assert(x): asserts x is T Throw if type guard fails

Common Mistakes

Mistake Correct Pattern
Using any without justification Use unknown and narrow with type guards
Manual type assertions everywhere Let inference work, type function returns
Destructuring before type narrowing Keep object intact for discriminated unions
Index access without undefined check Enable noUncheckedIndexedAccess
as Type casting unsafe values Use satisfies Type to preserve narrow types
Inline objects in generics Extract to const or type alias
Omitting extends in constraints Always constrain generics when possible
Using Parameters<typeof fn>[0] Type the parameter directly in function
Not handling union exhaustiveness Use never checks in switch/if-else
value as const satisfies Type Use satisfies Type then as const if needed

Delegation

  • Pattern discovery: Use Explore agent to find existing patterns in codebase
  • Type error debugging: Use Task agent for multi-step type resolution
  • Code review: Delegate to code-reviewer skill for type safety audit

References

GitHub 仓库 ↗ ← 返回陌讯 Skills 聚合平台
本页面由 陌讯 Skills 聚合平台 收录整理，数据定期更新。