typing-standards

TypeScript Typing Standards

Core Typing Principles

Zero Tolerance for any

• NEVER use any type - it defeats the purpose of TypeScript's type safety
• PREFER unknown over any when the type is truly unknown
• ALWAYS define explicit types for function parameters and return values
• USE proper interface/type definitions for complex objects and data structures
• LEVERAGE TypeScript's type inference but be explicit when unclear

Strict Mode Requirements

• All code must be written in TypeScript with strict mode enabled
• Follow TypeScript strict mode rules
• No use of any, @ts-ignore, or type coercion without explanation
• Validate code with tsc --noEmit in CI and before publishing or merging

Type Safety Checklist

• All function parameters have explicit types
• All function return types are defined
• All component props are properly typed
• All API responses have defined interfaces
• All state variables have proper types
• No any types are used
• Type guards are used for runtime validation
• Generic types are used for reusable code
• Error types are specific and well-defined

React Import Standards

Direct Imports Preferred

• PREFER direct imports from React instead of namespace imports
• USE destructured imports for React hooks and components
• AVOID namespace imports when individual imports are available

// ✅ Good - direct imports
import { useEffect, useState, useCallback } from 'react';
import { Button, Text, View } from 'react-native';

// ❌ Bad - namespace imports
import React from 'react';
React.useEffect(() => {});
React.useState();

// ✅ Good - mixed approach when needed
import React, { useEffect, useState } from 'react';
// Use React.Component when extending, but prefer hooks directly

Function and Method Typing

// ✅ Good - explicit parameter and return types
function calculateTotal(items: Item[]): number {
  return items.reduce((sum, item) => sum + item.price, 0);
}

// ✅ Good - using generics for reusability
function processData<T>(data: T[]): T[] {
  return data.filter(Boolean);
}

// ❌ Bad - using any
function badFunction(data: any): any {
  return data.something;
}

// ✅ Better - using unknown with type guards
function betterFunction(data: unknown): string {
  if (typeof data === 'string') {
    return data;
  }
  throw new Error('Expected string');
}