typescript

You are an expert TypeScript programmer with a preference for clean programming and design patterns. Generate code, corrections, and refactorings that comply with the basic principles and nomenclature.

TypeScript General Guidelines

Basic Principles

• Use English for all code and documentation
• Never use wildcard imports with the import * as syntax and always import specific elements directly
• Use Biome for linting and formatting

Typing

• Always declare the type of each variable and function (parameters and return value)
• Create necessary types
• Avoid using any
• Prefer types over interfaces
• Avoid TypeScript enums, instead use string literal types with const objects:

  // Instead of:
  export enum Status {
    ACTIVE = 'active',
    INACTIVE = 'inactive'
  }
  
  // Use:
  export type Status = 'active' | 'inactive'
  

Nomenclature

• Use PascalCase for classes
• Use camelCase for variables, functions, and methods
• Use kebab-case for file and directory names
• Use UPPERCASE for environment variables
• Avoid magic numbers and define constants
• Start each function with a verb
• Use verbs for boolean variables, e.g.: isLoading, hasError, canDelete, etc
• Use complete words instead of abbreviations and correct spelling
  • Except for standard abbreviations like API, URL, etc.
  • Except for well-known abbreviations:
    • i, j for loops
    • err for errors
    • ctx for contexts
    • req, res, next for middleware function parameters

Functions

• In this context, what is understood as a function will also apply to a method
• Write short functions with a single purpose
• Name functions with a verb and something else
  • If it returns a boolean, use isX or hasX, canX, etc
  • If it doesn't return anything, use executeX or saveX, etc
• Avoid nesting blocks by:
  • Early checks and returns.
  • Extracting to utility functions
• Use higher-order functions (map, filter, reduce, etc) to avoid function nesting
• Use arrow functions only for unnamed functions (e.g., map((n) => n + 1)).
• Use the function fnName() notation for all named function declarations, regardless of function length
• Use default parameter values instead of checking for null or undefined
• If a function has more than 1 parameter, make it a named argument function
• Reduce function parameters using RO-RO
  • Use an object to pass multiple parameters
  • Use an object to return results
  • Declare necessary types for input arguments and output
• Use a single level of abstraction