How to fix 'super' must be called before accessing properties on 'this' in a derived class in TypeScript

// ❌ WRONG: Accessing "this" before super()
class Derived extends Base {
  constructor(value: string) {
    this.someProperty = value;  // Error: "this" before super()
    super();
  }
}

// ✅ CORRECT: Call super() first
class Derived extends Base {
  constructor(value: string) {
    super();  // Parent initialized first
    this.someProperty = value;  // Now safe to use "this"
  }
}

// ❌ WRONG: Trying to process data before passing to parent
class User extends Person {
  constructor(name: string, age: number) {
    const processedName = name.trim();  // Error: "this" not available yet
    super(processedName, age);
  }
}

// ✅ CORRECT: Process arguments before constructor, or pass directly
class User extends Person {
  constructor(name: string, age: number) {
    // Process arguments before calling super()
    const processedName = name.trim();
    super(processedName, age);  // Parent gets processed values
  }
}

// ✅ ALTERNATIVE: Use a factory method if complex processing is needed
class User extends Person {
  private constructor(name: string, age: number) {
    super(name, age);
  }

  static create(name: string, age: number): User {
    const processedName = name.trim();
    return new User(processedName, age);
  }
}

// ❌ WRONG: Property initializer using "this" before super()
class Derived extends Base {
  private calculatedValue = this.computeValue();  // Error: "this" in initializer

  constructor() {
    super();
  }

  private computeValue(): number {
    return 42;
  }
}

// ✅ CORRECT: Initialize in constructor after super()
class Derived extends Base {
  private calculatedValue: number;

  constructor() {
    super();
    this.calculatedValue = this.computeValue();  // Safe after super()
  }

  private computeValue(): number {
    return 42;
  }
}

// ✅ ALTERNATIVE: Use a static method if no instance needed
class Derived extends Base {
  private calculatedValue = Derived.computeStaticValue();

  constructor() {
    super();
  }

  private static computeStaticValue(): number {
    return 42;
  }
}

// ❌ WRONG: Parameter property with "this" reference
class Derived extends Base {
  constructor(private value = this.getDefault()) {  // Error: "this" in default
    super();
  }

  private getDefault(): string {
    return 'default';
  }
}

// ✅ CORRECT: Handle default values differently
class Derived extends Base {
  private value: string;

  constructor(value?: string) {
    super();
    this.value = value ?? this.getDefault();  // Safe after super()
  }

  private getDefault(): string {
    return 'default';
  }
}

// ✅ ALTERNATIVE: Use undefined check with default parameter
class Derived extends Base {
  constructor(private value?: string) {
    super();
    if (this.value === undefined) {
      this.value = this.getDefault();
    }
  }

  private getDefault(): string {
    return 'default';
  }
}

// ❌ WRONG: Calling method that uses "this" before super()
class Derived extends Base {
  constructor() {
    this.initialize();  // Error: Method uses "this" internally
    super();
  }

  private initialize(): void {
    this.setup();  // Uses "this"
  }
}

// ✅ CORRECT: Call methods after super()
class Derived extends Base {
  constructor() {
    super();
    this.initialize();  // Safe after parent is initialized
  }

  private initialize(): void {
    this.setup();
  }
}

// ❌ WRONG: Arrow function in parameter default
class Derived extends Base {
  constructor(callback = () => this.doSomething()) {  // Error: "this" in arrow function
    super();
  }
}

// ✅ CORRECT: Handle callback initialization differently
class Derived extends Base {
  private callback: () => void;

  constructor(callback?: () => void) {
    super();
    this.callback = callback ?? (() => this.doSomething());  // Safe
  }
}

// tsconfig.json
{
  "compilerOptions": {
    "strict": true,
    "strictPropertyInitialization": true,  // Catches uninitialized properties
    "noImplicitThis": true,  // Catches "this" with implicit 'any' type
    "target": "es2015"  // or higher for proper class support
  }
}