How to fix Static members cannot reference class type parameters in TypeScript

// BEFORE - Error
class Container<T> {
  static defaultValue: T;  // Error: Static members cannot reference class type parameters

  constructor(public value: T) {}
}

// AFTER - Convert to instance property
class Container<T> {
  defaultValue: T;  // Now an instance property

  constructor(defaultValue: T) {
    this.defaultValue = defaultValue;
  }
}

// Usage
const stringContainer = new Container<string>("default");
const numberContainer = new Container<number>(0);

// BEFORE - Error
class Container<T> {
  static createDefault(): T {  // Error
    // ... implementation
  }
}

// AFTER - Static method with its own type parameter
class Container<T> {
  static createDefault<U>(): U {  // Different type parameter
    // ... implementation returns U
  }

  // Or if it should create Container instances:
  static createContainer<U>(value: U): Container<U> {
    return new Container(value);
  }
}

// Usage
const stringContainer = Container.createContainer<string>("hello");
const numberContainer = Container.createContainer<number>(42);

// Base class without generics for static members
class ContainerBase {
  static readonly VERSION = "1.0.0";
  static readonly DEFAULT_NAME = "Container";

  static log(message: string) {
    console.log(`[${this.DEFAULT_NAME}] ${message}`);
  }
}

// Generic subclass for instance members
class Container<T> extends ContainerBase {
  constructor(public value: T) {
    super();
  }

  // Instance methods can use T
  getValue(): T {
    return this.value;
  }
}

// Usage
Container.log("Creating container");  // Static method from base class
const container = new Container<string>("test");

// Generic container class
class Container<T> {
  constructor(public value: T) {}

  getValue(): T {
    return this.value;
  }
}

// Separate utility for static operations
namespace ContainerUtils {
  export function createDefault<T>(): Container<T> {
    // Return default container of type T
    // Implementation depends on what default means for T
    throw new Error("Implement based on T");
  }

  export function merge<T>(a: Container<T>, b: Container<T>): Container<T> {
    // Merge logic
    throw new Error("Implement merge logic");
  }
}

// Or as a separate class
class ContainerFactory {
  static createDefault<T>(): Container<T> {
    return new Container<T>(/* default for T */);
  }

  static createFromArray<T>(items: T[]): Container<T[]> {
    return new Container(items);
  }
}

// Usage
const factoryCreated = ContainerFactory.createDefault<string>();
const utilsCreated = ContainerUtils.createDefault<number>();

// Advanced: Using conditional types for static factory
interface ContainerConstructor {
  new <T>(value: T): Container<T>;
  createDefault: <T>() => Container<T>;
}

class Container<T> {
  constructor(public value: T) {}

  // Type assertion to add static method to constructor
  static createDefault = function<T>(): Container<T> {
    // Implementation
    return new Container<T>(/* default */);
  } as <T>() => Container<T>;
}

// Or using a different pattern with a registry
class Container<T> {
  private static defaultRegistry = new Map<Function, any>();

  constructor(public value: T) {}

  static registerDefault<T>(ctor: new () => Container<T>, defaultValue: T) {
    this.defaultRegistry.set(ctor, defaultValue);
  }

  static createDefault<T>(ctor: new (value: T) => Container<T>): Container<T> {
    const defaultValue = this.defaultRegistry.get(ctor);
    if (defaultValue === undefined) {
      throw new Error("No default registered for this container type");
    }
    return new ctor(defaultValue);
  }
}

// Usage
Container.registerDefault(Container, "default");
const defaultContainer = Container.createDefault(Container<string>);

// Question: Do you need static methods, or would instance methods work?
// Often, factory functions outside the class are cleaner:

// Instead of:
// class Container<T> {
//   static create(value: T): Container<T> { ... }
// }

// Consider:
class Container<T> {
  constructor(public value: T) {}
}

// Factory function (not static method)
function createContainer<T>(value: T): Container<T> {
  return new Container(value);
}

// Or using a constructor type
type ContainerConstructor<T> = new (value: T) => Container<T>;

function createContainerWithCtor<T>(
  ctor: ContainerConstructor<T>,
  value: T
): Container<T> {
  return new ctor(value);
}

// Usage
const container1 = createContainer<string>("hello");
const container2 = createContainerWithCtor(Container, 42);