typescript-patterns

typescript-patterns starts from one guiding principle: push the type system to do real work instead of fighting it, since the compiler is most useful when it can prove a program's shape. It is the "how"; for the "what" and "when" (the decisions about which pattern to reach for), it points to the TypeScript rules in the same repository. Strict mode is the baseline: strict true is not optional in a healthy codebase, and if a codebase cannot compile under strict, that is a migration task, not an excuse to leave the flag off, with a strict, discriminating baseline config including noUncheckedIndexedAccess, exactOptionalPropertyTypes, noImplicitOverride, and verbatimModuleSyntax. Any is treated as a bug, not a tool: prefer unknown and narrow it, with explicit loosening and a comment when a fallback is truly needed. Public APIs get explicit types while locals get inference; interfaces are for object shapes that may be extended or implemented, types for unions, intersections, tuples, mapped types, and utility types; discriminated unions are the default state machine, with exhaustive checking as a free compiler feature; brands add nominal safety where structure is not enough; generics model caller-dependent types; and functions with more than a couple of knobs take a single options object. Narrowing and runtime safety rules cover validating at the boundary and trusting inside, type predicates and assertion functions, and readonly by default. Error handling covers failing at the boundary and handling at the edge, Result types for expected failures, and preserving error context with cause. Async patterns cover Promise.allSettled for independent fan-out, bounded concurrency, and timeouts and cancellation with AbortSignal. It also covers null and undefined discipline, small named modules with deliberate public surfaces, avoiding barrel bloat and circular imports, splitting by dependency direction, diagnosing before adding dependencies, runtime validation rather than type-of-trust, incremental compiler speed, types being free while structures are not, memoizing idempotent computation, type-level testing with expectTypeOf and satisfies, and tooling integration with tsc, Vitest, typescript-eslint, and Prettier. Anti-patterns to avoid: any as a speed hack, lying as casts, deeply nested callbacks, enum coercion bugs, giant god types, optional-only option objects, silent catch, and mixing sync and async error paths. Credit: created by affaan-m, in the ecc collection. Licence: the vetted file states no licence, so it is recorded as non indiquée. Source: https://github.com/affaan-m/ecc, file skills/typescript-patterns/SKILL.md.