How to fix Parameter 'x' of constructor gets a default value, which is not allowed in TypeScript

// ERROR: Parameter 'name' of constructor gets a default value, which is not allowed
class User {
  constructor(
    public name: string = "Guest"  // WRONG - public modifier with default value
  ) {}
}

// CORRECT - Initialize in constructor body
class User {
  constructor(
    public name: string  // No default value here
  ) {
    // Provide default in constructor body if needed
    if (!name) {
      this.name = "Guest";
    }
  }
}

// OR with explicit default logic
class User {
  constructor(
    public name: string
  ) {
    this.name = name || "Guest";
  }
}

// CORRECT - Optional parameter with default, manual assignment
class User {
  name: string;
  
  constructor(
    name?: string  // Optional parameter, no visibility modifier
  ) {
    this.name = name || "Guest";  // Assign with default
  }
}

// Alternative: Use destructuring with defaults
class User {
  name: string;
  
  constructor(options: { name?: string } = {}) {
    this.name = options.name || "Guest";
  }
}

// CORRECT - Separate property declaration with default
class User {
  public name: string = "Guest";  // Default value here
  
  constructor(name?: string) {
    if (name !== undefined) {
      this.name = name;  // Override default if provided
    }
  }
}

// For multiple properties with defaults
class Config {
  public timeout: number = 5000;
  public retries: number = 3;
  
  constructor(options?: { timeout?: number; retries?: number }) {
    if (options?.timeout !== undefined) this.timeout = options.timeout;
    if (options?.retries !== undefined) this.retries = options.retries;
  }
}

// CORRECT - Factory method pattern
class User {
  private constructor(
    public name: string
  ) {}
  
  static create(name?: string): User {
    return new User(name || "Guest");
  }
}

// Usage
const user1 = User.create();           // name = "Guest"
const user2 = User.create("Alice");    // name = "Alice"

// Static constructor with options
class Config {
  constructor(
    public timeout: number,
    public retries: number
  ) {}
  
  static withDefaults(): Config {
    return new Config(5000, 3);
  }
  
  static fromOptions(options: Partial<Config>): Config {
    return new Config(
      options.timeout ?? 5000,
      options.retries ?? 3
    );
  }
}

// GOOD PATTERN - Parameter properties for required, separate handling for optional
class User {
  public id: string;           // Required - from constructor
  public name: string = "";    // Optional with default
  public age?: number;         // Truly optional
  
  constructor(
    id: string,               // Required, no modifier
    name?: string,
    age?: number
  ) {
    this.id = id;             // Assign required
    if (name) this.name = name;
    this.age = age;
  }
}

// BETTER - Clear separation
class User {
  constructor(
    public readonly id: string,      // Required, uses parameter property
    public name: string = "",        // ERROR - can't combine
    public age?: number              // ERROR - can't combine
  ) {}
}