Can class properties be automatically generated based on its generic type?

Question

Can class properties be automatically generated based on its generic type?

Is it possible in TypeScript to automatically create a class with properties based on its generic type? For example:

class CustomClass<T> {
  // Code to extract properties from T should go here
}

interface Characteristics {
  quality: string;
  price: number;
}

const item = new CustomClass<Characteristics>;

// Now, both item.quality and item.price will be available for autocompletion with the correct types specified in the 'Characteristics' interface

interface Attributes {
  color: string;
  size: number;
  weight: number;
}

const product = new CustomClass<Attributes>;
// Only the three attributes defined in 'Attributes' interface will be accessible for 'product'

I am looking for a solution that does not involve adding something like

class SomeClass {
  [property: string]: any
}

as this would allow any property to be added, whereas I specifically want to limit the properties to those defined in the generic type.

typescript typescript-generics

Answer 1

Answer №1

For the specific scenario you're describing, a mixin approach is more appropriate than traditional inheritance. However, TypeScript does not support generic mixins of the sort interface X<T> extends T.

To work around this limitation, you can define an object called SomeClass and a generic type named SomeClass<T>. You would need to incorporate some type assertions to make it functional. Below is a possible implementation:

class _SomeClass<T> {
    constructor(t: T) {
        Object.assign(this, t);
    }
    
    get<K extends keyof T>(k: K): T[K] {
        return (this as any as T)[k]; // assertion
    }
}
type SomeClass<T> = T & _SomeClass<T>;
const SomeClass = _SomeClass as new <T>(t: T) => SomeClass<T>;

Hopefully, this provides some insight into working with TypeScript in scenarios where certain features are not directly supported. Good luck!

Answer 2

For the specific scenario you're describing, a mixin approach is more appropriate than traditional inheritance. However, TypeScript does not support generic mixins of the sort interface X<T> extends T.

To work around this limitation, you can define an object called SomeClass and a generic type named SomeClass<T>. You would need to incorporate some type assertions to make it functional. Below is a possible implementation:

class _SomeClass<T> {
    constructor(t: T) {
        Object.assign(this, t);
    }
    
    get<K extends keyof T>(k: K): T[K] {
        return (this as any as T)[k]; // assertion
    }
}
type SomeClass<T> = T & _SomeClass<T>;
const SomeClass = _SomeClass as new <T>(t: T) => SomeClass<T>;

Hopefully, this provides some insight into working with TypeScript in scenarios where certain features are not directly supported. Good luck!

Answer 3

Answer №2

Classes are unable to utilize mapped types. However, with inspiration from the response found at: , a workaround can be achieved by creating a function that generates an object conforming to a specified interface:


interface Data {
  x: string;
  y: number;
}

function generate<T>(data?: T): T {
  return Object.assign({}, data);
}


const newData = generate<Data>();
// The newData object now includes properties x and y

// Alternatively, default values can be passed in
// const anotherData = generate<Data>({ x: 'example', y: 42 });

Answer 4

Classes are unable to utilize mapped types. However, with inspiration from the response found at: , a workaround can be achieved by creating a function that generates an object conforming to a specified interface:


interface Data {
  x: string;
  y: number;
}

function generate<T>(data?: T): T {
  return Object.assign({}, data);
}


const newData = generate<Data>();
// The newData object now includes properties x and y

// Alternatively, default values can be passed in
// const anotherData = generate<Data>({ x: 'example', y: 42 });

Can class properties be automatically generated based on its generic type?

Answer №1

Answer №2

Similar questions

I am puzzled as to why I am still facing the error message: "'node' is not recognized as an internal or external command, operable program or batch file."

Rejecting the request by clicking a button

I have successfully set up micro-cors on my system, and as I tried to compile, I received the following outcome

Is it possible for TypeScript to deduce the type of a discriminated union using "extracted" boolean logic?

Executing a child component function once the parent component data is loaded in Angular 5

Alert: Using Angularfire SDK could result in console log issues

Is it possible to define data types for the global context in cucumber?

What is the best way to obtain the dimensions of an image in Angular 2 (or newer) before uploading it to the server, and can this be accomplished without utilizing jQuery?

Using React.useMemo does not efficiently avoid unnecessary re-renders

Best practice in Angular 2: The difference between binding an object as a whole versus binding its individual

Guide on creating a Typescript Conditional type structure for Array elements that rely on each other

Guide to accessing nested form controls within an array and object in Angular Reactive Forms

Experience screen sharing through WEBRTC without the need for any additional browser extensions

Learn how to open a component in a new browser tab using Angular from a different component

A guide on retrieving data from Promises in Angular

Is the event emitter contained within the subscription?

Sorting the table in Angular Material is proving to be a challenge

Trouble integrating PDF from REST API with Angular 2 application

Gradle synchronization in IntelliJ causing missing folders in WAR Artifact

Tips for retrieving an item from a (dropdown) menu in Angular