The standard category of class method parameter nature

Question

The standard category of class method parameter nature

I'm encountering difficulties when attempting to correctly define a method within a class. To begin with, here is the initial class structure:

export class Plugin {
    configure(config: AppConfig) {}
    beforeLaunch(config: AppConfig) {}
    afterSetup(runtime: Runtime) {}
    afterStartup(runtime: Runtime) {}
    onUserError(error: UserError) {}
}

Furthermore, there is another class responsible for programmatically executing some of these methods:

export class PluginManager {
    _plugins: Plugin[];
    _pythonPlugins: any[];

    constructor() {
        this._plugins = [];
        this._pythonPlugins = [];
    }

    private setUpPlugins = (property: keyof Plugin, parameter:AppConfig | Runtime | UserError ) => {
        for (const p of this._plugins) p[property](parameter); 
        for (const p of this._pythonPlugins) p[property]?.(parameter);
    }

The issue arises when the parameter in the initial programmatic call within setUpPlugins raises an error:

Argument of type 'AppConfig | Runtime | UserError' is not assignable to parameter of type 'AppConfig & Runtime & UserError'.
  Type 'AppConfig' is not assignable to type 'AppConfig & Runtime & UserError'.
    Type 'AppConfig' is missing certain properties from type 'Runtime'. (tsserver 2345)

The expectation for an intersection type rather than a union type is perplexing. I attempted addressing this using generics:

    private setUpPlugins = <T extends keyof Plugin, U extends Parameters<Plugin[T]>> (property: T, parameter:U ) => {
        for (const p of this._plugins) p[property](parameter);  
        for (const p of this._pythonPlugins) p[property]?.(parameter);
    }

However, a new error has surfaced regarding the parameter:

Argument of type '[config: AppConfig] | [config: AppConfig] | [runtime: Runtime] | [runtime: Runtime] | [error: UserError]' is not assignable to parameter of type 'AppConfig & Runtime & UserError'.
  Type '[config: AppConfig]' is not assignable to type 'AppConfig & Runtime & UserError'.
    Type '[config: AppConfig]' is not assignable to type 'Runtime'. (tsserver 2345)

What would be the correct approach to resolving this issue without resorting to the use of 'any'?

typescript typescript-generics

Answer 1

Answer №1

When organizing your code to call a union of functions, it's important to ensure type safety to avoid mismatched arguments being passed. In the example provided, the use of a union type for property (keyof Plugin) and parameter (AppConfig | Runtime | UserError) can lead to unsafe function calls.

To address this, leveraging an intersection of argument types, as outlined in the TypeScript documentation, is recommended. By defining parameter as AppConfig & Runtime & UserError, the compiler can ensure safe function calls regardless of the property passed.

Alternatively, you can establish proper correlation between property and parameter using generics. One approach is to define property as K extends keyof Plugin and parameter as Parameters<Plugin[K]>[0]. Although this approach provides some level of safety, the compiler may still treat them as uncorrelated union types.

For improved type safety and better compiler verification, consider refactoring the types to a mapped interface that clearly represents the intended correlation. By utilizing distributive object types and mapping over the interface, you can index into the relevant unions securely. This approach may require more work upfront but results in improved compiler understanding and verification.

For the provided code example, refactoring to an interface like PluginParam and a related mapping type PluginMethods can establish the necessary correlation. By implementing PluginMethods in the Plugin class, type safety can be maintained through explicit representation of generic mapped versions.

By annotating variables and ensuring all operations are performed in terms of mapped types on basic mapping interfaces, you can enhance type safety and avoid errors. This structured approach allows the compiler to verify the code as safe and ensures proper correlation between function calls and arguments.

For further exploration and experimentation, consider using the provided Playground link can aid in further understanding and experimentation.

Answer 2

When organizing your code to call a union of functions, it's important to ensure type safety to avoid mismatched arguments being passed. In the example provided, the use of a union type for property (keyof Plugin) and parameter (AppConfig | Runtime | UserError) can lead to unsafe function calls.

To address this, leveraging an intersection of argument types, as outlined in the TypeScript documentation, is recommended. By defining parameter as AppConfig & Runtime & UserError, the compiler can ensure safe function calls regardless of the property passed.

Alternatively, you can establish proper correlation between property and parameter using generics. One approach is to define property as K extends keyof Plugin and parameter as Parameters<Plugin[K]>[0]. Although this approach provides some level of safety, the compiler may still treat them as uncorrelated union types.

For improved type safety and better compiler verification, consider refactoring the types to a mapped interface that clearly represents the intended correlation. By utilizing distributive object types and mapping over the interface, you can index into the relevant unions securely. This approach may require more work upfront but results in improved compiler understanding and verification.

For the provided code example, refactoring to an interface like PluginParam and a related mapping type PluginMethods can establish the necessary correlation. By implementing PluginMethods in the Plugin class, type safety can be maintained through explicit representation of generic mapped versions.

By annotating variables and ensuring all operations are performed in terms of mapped types on basic mapping interfaces, you can enhance type safety and avoid errors. This structured approach allows the compiler to verify the code as safe and ensures proper correlation between function calls and arguments.

For further exploration and experimentation, consider using the provided Playground link can aid in further understanding and experimentation.

The standard category of class method parameter nature

Answer №1

Similar questions

Extracting and retrieving the value from the paramMap in Angular/JavaScript

Properties are determined by both the type and sub-type

Bespoke Socket.io NodeJS chamber

The type '{ children: Element[]; }' does not include the properties 'location' and 'navigator' that are present in the 'RouterProps' type

Error in Angular 5: Google Maps not defined

What can TypeScript do with high-level type functions?

Using JavaScript to assign function arguments based on arbitrary object values

Monitor the true/false status of each element within an array and update their styles accordingly when they are considered active

Angular 5 and the benefits of concurrent requests

styled components are having issues with background gradients and opacity not functioning properly

Transferring dynamic parameters from a hook to setInterval()

The API request does not provide randomized results and does not show any display

Hold off on making any promises regarding Angular 2

Utilize the CSS class or variable within an Angular TypeScript file for enhanced styling and functionality

Is the return type of 'void' being overlooked in TypeScript - a solution to avoid unresolved promises?

Angular data table is currently displaying an empty dataset with no information available

Encrypting and decrypting data using RSA in TypeScript

Tip Sheet: Combining Elements from an Array of Objects into a Single Array

The TypeScript error "File 'XXX' is not recognized as a module" is preventing successful compilation

Exploring Vue.js lifecycle events and when to begin loading store properties (Vue.observable)