How to fix Property 'x' is declared in class 'X' but its initializer or other property definition is missing in TypeScript

// BEFORE - Error
class User {
  name: string;  // Error: Property 'name' has no initializer
}

// AFTER - Fixed with initial value
class User {
  name: string = '';  // Initialize with empty string
  age: number = 0;    // Initialize with 0
  isActive: boolean = false;  // Initialize with false
  tags: string[] = [];  // Initialize with empty array
}

// For complex types, use appropriate defaults
class Config {
  settings: Record<string, any> = {};
  timeout: number = 5000;
  retries: number = 3;
}

// BEFORE - Error
class User {
  name: string;
  age: number;

  constructor(firstName: string, lastName: string, birthYear: number) {
    // Error: Properties not initialized
  }
}

// AFTER - Fixed in constructor
class User {
  name: string;
  age: number;

  constructor(firstName: string, lastName: string, birthYear: number) {
    this.name = `${firstName} ${lastName}`;
    this.age = new Date().getFullYear() - birthYear;
  }
}

// For optional parameters with defaults
class Product {
  name: string;
  price: number;
  discount: number;

  constructor(name: string, price: number, discount?: number) {
    this.name = name;
    this.price = price;
    this.discount = discount ?? 0;  // Use nullish coalescing for default
  }
}

// Use ! when you guarantee initialization
class Database {
  connection!: Connection;  // ! tells TypeScript "trust me, this will be initialized"

  async initialize() {
    this.connection = await createConnection();
  }
}

// For properties set by frameworks or dependency injection
class Controller {
  service!: Service;  // Injected by framework

  // Framework will set this property before use
}

// For lazy initialization
class Cache {
  data!: Map<string, any>;

  getData(): Map<string, any> {
    if (!this.data) {
      this.data = new Map();
    }
    return this.data;
  }
}

// WARNING: Only use ! when you're certain the property will be initialized
// before any access. Misuse can lead to runtime errors.

// Use ? for properties that may be undefined
class UserProfile {
  name: string;
  avatarUrl?: string;  // Optional - may be undefined
  bio?: string;        // Optional - may be undefined

  constructor(name: string) {
    this.name = name;
    // avatarUrl and bio can remain undefined
  }
}

// Access optional properties safely
const profile = new UserProfile('Alice');
console.log(profile.avatarUrl?.toUpperCase());  // Optional chaining
console.log(profile.bio ?? 'No bio provided');  // Nullish coalescing

// Interface with optional properties
interface Config {
  requiredSetting: string;
  optionalSetting?: number;
  anotherOptional?: boolean;
}

// Class implementing interface
class AppConfig implements Config {
  requiredSetting: string;
  optionalSetting?: number;

  constructor(required: string) {
    this.requiredSetting = required;
  }
}

// OPTION 1: Disable strictPropertyInitialization only
{
  "compilerOptions": {
    "strict": true,
    "strictPropertyInitialization": false  // Disable just this check
  }
}

// OPTION 2: Disable all strict checks (not recommended)
{
  "compilerOptions": {
    "strict": false  // Disables all strict checks including property initialization
  }
}

// OPTION 3: Use overrides for specific files (TypeScript 4.1+)
{
  "compilerOptions": {
    "strict": true
  },
  "files": [
    "src/strict-code.ts"
  ],
  "include": [
    "src/**/*"
  ],
  "exclude": [
    "src/legacy/**/*"  // Legacy code without strict checks
  ]
}

// BEFORE - Error: Property may be undefined
class Auth {
  token: string;

  constructor(useToken: boolean) {
    if (useToken) {
      this.token = 'generated-token';
    }
    // Error: token not assigned when useToken is false
  }
}

// AFTER 1: Assign in all branches
class Auth {
  token: string;

  constructor(useToken: boolean) {
    if (useToken) {
      this.token = 'generated-token';
    } else {
      this.token = '';  // Assign default in else branch
    }
  }
}

// AFTER 2: Use ternary operator
class Auth {
  token: string;

  constructor(useToken: boolean) {
    this.token = useToken ? 'generated-token' : '';
  }
}

// AFTER 3: Initialize with default, then conditionally update
class Auth {
  token: string = '';  // Initialize with default

  constructor(useToken: boolean) {
    if (useToken) {
      this.token = 'generated-token';
    }
  }
}

// AFTER 4: Make property optional if it can be undefined
class Auth {
  token?: string;  // Mark as optional

  constructor(useToken: boolean) {
    if (useToken) {
      this.token = 'generated-token';
    }
  }
}