with-typescript

Rules For Typescript Types

Follow these rules and standards when creating or editing types:

• The less code it takes to define a type the better
• Derive dynamic types from values instead of repeating values that already exist
• Reuse and extend existing types instead of creating whole new types
• BAD: duplicating types in the project
• BAD: redundant type declaration
• BAD: manual type annotation
• BAD: non-inferential typing
• Consolidate or share similar types across files instead of creating similar ones for each file. Examples:
  • Finding and using the types.ts file or common export if they exist
  • By namespace merging and augmentation of very similar interfaces that exist across files instead of creating the same or similar type in every single file.
• GOOD type-level programming or type inference-driven type construction
• GOOD: typeof inference: capturing runtime shapes for type use
• GOOD: mapped types: transforming types over keys
• GOOD: indexed access types: extracting types via [K]
• GOOD: template literal types: for strings and key construction.
• GOOD: conditional types: shaping types based on logic

Examples: GOOD Typescript Methods

The following Typescript methods are preferred.

• satisfies

  • Ensures a value conforms to a type without losing literal types

    • const config = {
        mode: 'dev',
        verbose: true,
      } satisfies Record<string, unknown>
      

• infer

  • Extracts types inside conditional types

    • type ElementType<T> = T extends (infer U)[] ? U : T
      

• keyof with typeof

  • Gets literal keys from objects or arrays

    • const flags = ['--help', '--verbose'] as const
      type Flag = (typeof flags)[number] // "--help" | "--verbose"
      

• ReturnType, Parameters, ConstructorParameters

  • Extracts return values, arguments, and constructor params from functions

    • type Fn = (x: number) => string
      type R = ReturnType<Fn> // string