How can I define the type of a constructor that requires a parameter in TypeScript?

Question

How can I define the type of a constructor that requires a parameter in TypeScript?

Having identified the issue, let's focus on a minimal example:

// interfaces:

    interface ClassParameter{
        x:number
    }

    interface ClassParameterNeeder{
        y:number
    }

    type ClassParameterConstructor = new () => ClassParameter

    type ClassParameterNeederConstructor =
        new (cpc: ClassParameterConstructor) => ClassParameterNeeder

    // implementations:

    class MyClassParameter implements ClassParameter{
        x = 12
        extraField = 27
    }

    class MyClassParameterNeeder implements ClassParameterNeeder{
        y = 19
        otherExtraField = 29
        constructor(mcpc: new() => MyClassParameter) {}
    }

    let doesntWork:ClassParameterNeederConstructor = MyClassParameterNeeder

Regarding TypeScript's complaint about the final line:

let doesntWork: ClassParameterNeederConstructor
    Type 'typeof MyClassParameterNeeder' is not assignable to type 'ClassParameterNeederConstructor'.
      Types of parameters 'mcpc' and 'cpc' are incompatible.
        Type 'ClassParameterConstructor' is not assignable to type 'new () => MyClassParameter'.
          Property 'extraField' is missing in type 'ClassParameter' but required in type 'MyClassParameter'.(2322)
    input.ts(22, 5): 'extraField' is declared here.

This situation led me to question the reversed dependency, which actually makes sense. In the definition of type ClassParameterNeederConstructor, an outer Constructor complying with that type must accept an inner ClassParameterConstructor capable of constructing any kind of ClassParameter, not just the specialized constructor for MyClassParameter. But then, how do I resolve this? It seems impossible to narrow the interface in the implementation, and the implementation cannot accept any kind of ClassParameterConstructor without specific requirements for MyClassParameter constructors...

Any assistance would be greatly appreciated!

EDIT:

Attempting to apply @jcalz's solution to my specific issue: Playground

Previously, I tried using generics but placed the <> after the new (line 26):

RigidBody: new<S extends ShapeInterface> (shapeClass: new () => S) => RigidBodyInterface<S>

Unfortunately, that didn't work. I have now moved it up into the constructor of PhysicsInterface (now on line 23) and it functions correctly.

However, I must now list all the abstract classes used by the engine in the generics parameter list, which is a bit cumbersome (especially since TypeScript doesn't display generics parameters as tooltips), but it seems necessary.

Another attempt was made to create a type-inferring factory, but it ultimately failed (the last line throws an error), and it's also quite confusing. I would also need a mechanism to inject engine-specific implementations for the physics engine class into the physics engine class factory, so I'll stick with method A.

Currently, the implementation allows a physics engine user to access the p2-specific members of the classes and they are visible in TypeScript code completion. Is there a way to keep that private while still allowing the engine itself to access all p2 fields? Something akin to using friend in C++...

I have a functional solution now, but any input on making the factory work or about the concept in general is appreciated.

Thank you!

typescript interface

Answer 1

Answer №1

Your MyClassParameterNeeder constructor code seems to be expecting a MyClassParameter constructor instead of an instance. To correct this, annotate mcpc as type typeof MyClassParameter or as new () => MyClassParameter:

class MyClassParameterNeeder implements ClassParameterNeeder {
   y = 19
   otherExtraField = 29
   constructor(mcpc: new () => MyClassParameter) { } // updated annotation
}

After this correction, another issue arises where MyClassParameterNeeder is not a valid ClassParameterNeederConstructor. This aligns with the underlying problem:

let doesntWork: ClassParameterNeederConstructor = MyClassParameterNeeder
//Type 'typeof MyClassParameterNeeder' is not assignable to type 'ClassParameterNeederConstructor'.
//Types of parameters 'mcpc' and 'cpc' are incompatible.
//Type 'new () => ClassParameter' is not assignable to type 'new () => MyClassParameter'.
//Property 'extraField' is missing in type 'ClassParameter' but required in type 'MyClassParameter'.

Your implementation of MyClassParameterNeeder specifies that mcpc must create instances of MyClassParameter exclusively. Therefore, the existing ClassParameterNeederConstructor type is not suitable. Consider a scenario with a new subclass:

class AnotherClassParameter implements ClassParameter {
   x = 12
   foo = true
}

class AnotherClassParameterNeeder implements ClassParameterNeeder {
   y = 19
   bar = false
   constructor(mcpc: new () => AnotherClassParameter) { }
}

It's imperative to maintain distinction between MyClassParameterNeeder and AnotherClassParameterNeeder without losing essential information. Attempting to create a common type may lead to either safety concerns or inconclusive outcomes:

type UselessClassParameterNeederConstuctor =
   new (cpc: new () => never) => ClassParameterNeeder

const uselessMine: UselessClassParameterNeederConstuctor = MyClassParameterNeeder;
const uselessAnother: UselessClassParameterNeederConstuctor = AnotherClassParameterNeeder;
new uselessMine(MyClassParameter); // error

Alternatively, a generic approach for ClassParameterNeederConstructor based on the generics concept is recommended:

type ClassParameterNeederConstructor<C extends ClassParameter> =
   new (cpc: new () => C) => ClassParameterNeeder

const genericMine: ClassParameterNeederConstructor<MyClassParameter> =
  MyClassParameterNeeder;
const genericAnother: ClassParameterNeederConstructor<AnotherClassParameter> =
  AnotherClassParameterNeeder;

new genericMine(MyClassParameter); // works
new genericAnother(AnotherClassParameter); // works
new genericMine(AnotherClassParameter); // error

This resolves the key issues!

To simplify the annotation process, a helper function can be used to automatically infer the type:

const asClassParameterNeederConstructor =
   <C extends ClassParameter>(c: ClassParameterNeederConstructor<C>) => c;

const inferredMine = asClassParameterNeederConstructor(MyClassParameterNeeder);
const inferredAnother = asClassParameterNeederConstructor(AnotherClassParameterNeeder);
new inferredMine(MyClassParameter); // works
new inferredAnother(AnotherClassParameter); // works
new inferredMine(AnotherClassParameter); // error

The types of inferredMine and inferredAnother will be inferred automatically based on usage. Good luck with your implementation!

For a live example, check the Playground link

Answer 2

Your MyClassParameterNeeder constructor code seems to be expecting a MyClassParameter constructor instead of an instance. To correct this, annotate mcpc as type typeof MyClassParameter or as new () => MyClassParameter:

class MyClassParameterNeeder implements ClassParameterNeeder {
   y = 19
   otherExtraField = 29
   constructor(mcpc: new () => MyClassParameter) { } // updated annotation
}

After this correction, another issue arises where MyClassParameterNeeder is not a valid ClassParameterNeederConstructor. This aligns with the underlying problem:

let doesntWork: ClassParameterNeederConstructor = MyClassParameterNeeder
//Type 'typeof MyClassParameterNeeder' is not assignable to type 'ClassParameterNeederConstructor'.
//Types of parameters 'mcpc' and 'cpc' are incompatible.
//Type 'new () => ClassParameter' is not assignable to type 'new () => MyClassParameter'.
//Property 'extraField' is missing in type 'ClassParameter' but required in type 'MyClassParameter'.

Your implementation of MyClassParameterNeeder specifies that mcpc must create instances of MyClassParameter exclusively. Therefore, the existing ClassParameterNeederConstructor type is not suitable. Consider a scenario with a new subclass:

class AnotherClassParameter implements ClassParameter {
   x = 12
   foo = true
}

class AnotherClassParameterNeeder implements ClassParameterNeeder {
   y = 19
   bar = false
   constructor(mcpc: new () => AnotherClassParameter) { }
}

It's imperative to maintain distinction between MyClassParameterNeeder and AnotherClassParameterNeeder without losing essential information. Attempting to create a common type may lead to either safety concerns or inconclusive outcomes:

type UselessClassParameterNeederConstuctor =
   new (cpc: new () => never) => ClassParameterNeeder

const uselessMine: UselessClassParameterNeederConstuctor = MyClassParameterNeeder;
const uselessAnother: UselessClassParameterNeederConstuctor = AnotherClassParameterNeeder;
new uselessMine(MyClassParameter); // error

Alternatively, a generic approach for ClassParameterNeederConstructor based on the generics concept is recommended:

type ClassParameterNeederConstructor<C extends ClassParameter> =
   new (cpc: new () => C) => ClassParameterNeeder

const genericMine: ClassParameterNeederConstructor<MyClassParameter> =
  MyClassParameterNeeder;
const genericAnother: ClassParameterNeederConstructor<AnotherClassParameter> =
  AnotherClassParameterNeeder;

new genericMine(MyClassParameter); // works
new genericAnother(AnotherClassParameter); // works
new genericMine(AnotherClassParameter); // error

This resolves the key issues!

To simplify the annotation process, a helper function can be used to automatically infer the type:

const asClassParameterNeederConstructor =
   <C extends ClassParameter>(c: ClassParameterNeederConstructor<C>) => c;

const inferredMine = asClassParameterNeederConstructor(MyClassParameterNeeder);
const inferredAnother = asClassParameterNeederConstructor(AnotherClassParameterNeeder);
new inferredMine(MyClassParameter); // works
new inferredAnother(AnotherClassParameter); // works
new inferredMine(AnotherClassParameter); // error

The types of inferredMine and inferredAnother will be inferred automatically based on usage. Good luck with your implementation!

For a live example, check the Playground link

How can I define the type of a constructor that requires a parameter in TypeScript?

Answer №1

Similar questions

Slate - developing a TypeScript function to filter and retrieve an object containing the highest property value

An object resulting from the combination of two separate objects

Angular 2 code test coverage

"Error: The property $notify is not found in the type" - Unable to utilize an npm package in Vue application

Tips on displaying the entire text when hovering over it

A guide to successfully transferring data array values from a Parent Component to a Child Component using APIs in Angular

Create a specific definition for a packaged item with limited access

Expanding Mongoose Schema with Typescript: A Comprehensive Guide

Retrieve the property of a Typescript object using a template argument

Adding additional properties to Material UI shadows in Typescript is a simple process that can enhance the visual

Do we really need Renderer2 in Angular?

Creating a grid UI in AngularJS using Typescript: utilizing functions as column values

Swapping Out Imports with Window Objects in TypeScript

What is the best way to test the SSM getParameter function using Jasmine?

The error "Property 'push' does not exist on type '() => void'" occurs with Angular2 and Typescript arrays

When the *ngFor directive disrupts the CSS Grid Layout, resulting in all items being displayed in a single column

Guide on setting up a route in Next.js

Why does the custom method only trigger once with the addEventListener?

Migrating image information from Angular version 14 to Asp.Net Core 6.0 Rest Api

TypeScript Error 2304: Element 'div' is nowhere to be found - CRA TypeScript Template