Is there a way to verify whether a key within an Interface corresponds to a class that is a subclass of a specific Parent

Question

Is there a way to verify whether a key within an Interface corresponds to a class that is a subclass of a specific Parent

Is there a method in typescript to ensure that a property in an interface must be of type "child subclass C, which extends class P"?

example.ts

import { P } from '/path/to/types'
class C extends P {
   ...
}

types.ts

// `C` cannot be accessed here
class P {
   ...
}


interface {
    myProp: ???? <-- how to ensure `myProp` is a subclass of P (class, not instance)?
}

Alternatively, I could verify

Object.getPrototypeOf(myProp.prototype) === P.prototype

at runtime. Is there a way to enforce this requirement through types at compile/checker time?

class typescript prototype

Answer 1

Answer №1

To determine the type, you can utilize the typeof method:

class P { ... }
interface Foo {
    myProp: typeof P
}
//Implementation
class C extends P { ... }
class D { ... }
//Valid
var f: Foo = {
    myProp: C
}
// Invalid
var f2: Foo = {
    myProp: D
}

This approach ensures that the chosen class for the property aligns with P.

Update

Considering that Typescript follows structural compatibility, any class matching the structure of P will be deemed compatible with typeof P. However, if P consists solely of public members and a limited number of members, there is a possibility that another class could unintentionally have a similar structure. To exclusively allow classes directly inheriting P to be compatible, a private member can be incorporated into P to render it incompatible with other classes (variations in private field declarations do not equate to compatibility).

class P { private nonStructural:true }
interface Foo {
    myProp: typeof P
}
//Implementation
class C extends P { }
class D { private nonStructural:true }
//Valid
var f: Foo = {
    myProp: C
}
// Invalid
var f2: Foo = {
    myProp: D
}

Answer 2

To determine the type, you can utilize the typeof method:

class P { ... }
interface Foo {
    myProp: typeof P
}
//Implementation
class C extends P { ... }
class D { ... }
//Valid
var f: Foo = {
    myProp: C
}
// Invalid
var f2: Foo = {
    myProp: D
}

This approach ensures that the chosen class for the property aligns with P.

Update

Considering that Typescript follows structural compatibility, any class matching the structure of P will be deemed compatible with typeof P. However, if P consists solely of public members and a limited number of members, there is a possibility that another class could unintentionally have a similar structure. To exclusively allow classes directly inheriting P to be compatible, a private member can be incorporated into P to render it incompatible with other classes (variations in private field declarations do not equate to compatibility).

class P { private nonStructural:true }
interface Foo {
    myProp: typeof P
}
//Implementation
class C extends P { }
class D { private nonStructural:true }
//Valid
var f: Foo = {
    myProp: C
}
// Invalid
var f2: Foo = {
    myProp: D
}

Is there a way to verify whether a key within an Interface corresponds to a class that is a subclass of a specific Parent

Answer №1

Similar questions

Quick way to specify type for Observable in Typescript

Getting the local path of a file from an input file in Angular 7

Having trouble with the react event handler for the renderedValue component in Material UI?

Leverage Async Await for Setting Response Data in TypeScript

Is there a way to retrieve the initial item of a JSON array from an HTML document using Angular 2?

Utilize Angular 2 Form Elements Again

Restricting HTTP requests to once every 200 milliseconds in Angular 4 with filtering in place

A guide on utilizing the useEffect hook to dynamically update a button icon when hovering over it in a React application

Creating a read-only DIV using Angular - a step-by-step guide

Unexpected token { in Fuse-Box when using Typescript

Tips for verifying the presence of a specific value within an array of union types

Developing a constructor method that is conscious of data types

What is the unit testing framework for TypeScript/JavaScript that closely resembles the API of JUnit?

What is the best way to export an overloaded function in TypeScript?

Tips for assessing the prop that is being passed to a styled component with React and TypeScript

Enhancing ES6 capabilities with Angular polyfills

Animating Angular ng-template on open/close state status

Implementing Generic Redux Actions in Typescript with Iterable Types

Using Vue.js 3 and Bootstrap 5 to Create a Custom Reusable Modal Component for Programmatically Showing Content

Incorporate a fresh attribute to the JSON data in an Angular API response