Typescript Class as parameter that extends another class

In TypeScript, you can define a class as a parameter in a function, and you can also ensure that the class passed as a parameter extends another class using TypeScript's generics.

Here's an example of how you can define a function that takes a class as a parameter, and the class should extend a specified base class:

typescriptCopy code
class BaseClass {
  // BaseClass properties and methods
}

class ExtendedClass extends BaseClass {
  // ExtendedClass properties and methods
}

function doSomethingWithClass<T extends BaseClass>(inputClass: new () => T) {
  // Create an instance of the class
  const instance = new inputClass();

  // Perform some actions with the instance
  // ...

  // Return the instance or do something else with it
}

// Example usage:
doSomethingWithClass(ExtendedClass);

In the example above, we have a BaseClass and an ExtendedClass, where ExtendedClass extends BaseClass. The doSomethingWithClass function takes a generic parameter T that extends BaseClass. We use TypeScript's generic constraint syntax <T extends BaseClass> to ensure that the class passed as a parameter must extend BaseClass.

Inside the doSomethingWithClass function, we create an instance of the class specified by the inputClass parameter, and then we can perform some actions with the instance.

When calling doSomethingWithClass(ExtendedClass), it will work because ExtendedClass extends BaseClass, and it satisfies the constraint defined in the function.

However, if you try to call doSomethingWithClass with a class that does not extend BaseClass, TypeScript will show an error:

typescriptCopy code
class AnotherClass {
  // AnotherClass properties and methods
}

doSomethingWithClass(AnotherClass); // This will result in a TypeScript error

Using generics in this way allows you to ensure that the class passed to the function meets specific criteria, which can help in creating more robust and type-safe code.