npm package: @fnet/invoke
Description: The `@fnet/invoke` module provides a simple utility for dynamically invoking methods on an object. It facilitates calling a specific method without having pre-defined knowledge of its name or the arguments it requires. This tool proves beneficial in scena
Latest version: 0.1.4

# @fnet/invoke

The `@fnet/invoke` module provides a simple utility for dynamically invoking methods on an object. It facilitates calling a specific method without having pre-defined knowledge of its name or the arguments it requires. This tool proves beneficial in scenarios where methods need to be invoked dynamically based on runtime data or configurations.

## How It Works

`@fnet/invoke` operates by taking a target object along with the name of a method you wish to call and any necessary arguments. It will then execute the specified method with the provided arguments. This process is performed asynchronously, and the result of the invocation is returned, allowing you to handle it further in your application.

## Key Features

- **Dynamic Method Invocation**: Execute any method on an object even if the method name is determined at runtime.
- **Asynchronous Handling**: Supports asynchronous operations, allowing the handling of promises returned by methods.
- **Argument Passing**: Easily pass any required arguments to the method using an array structure.
- **Error Management**: Provides comprehensive error handling to ensure any issues during invocation are reported clearly.

## Conclusion

The `@fnet/invoke` module is a straightforward utility for flexibly calling methods on objects without the need for static method names or argument lists. This makes it a functional tool in environments where method names and their parameters need to be determined during execution rather than at compile time.


# @fnet/invoke Developer Guide

## Overview
The `@fnet/invoke` library provides a simple mechanism for dynamically invoking methods on target objects. This library is useful when you need to execute a method without prior knowledge of the method's name or its argument list. By leveraging this functionality, you can develop flexible and dynamic applications that adapt to various target structures.

## Installation
To install the `@fnet/invoke` library, use npm or yarn. Choose one of the following commands according to your package manager preference:

```bash
npm install @fnet/invoke
```

or

```bash
yarn add @fnet/invoke
```

## Usage
To utilize the `@fnet/invoke` library, import it into your JavaScript or TypeScript project and use the `invoke` function to call a method on your target object dynamically.

### Example 1: Basic Usage
Here's a straightforward example of how to use `@fnet/invoke`:

```javascript
import invoke from '@fnet/invoke';

// Example target object
const targetObject = {
  hello(name) {
    return `Hello, ${name}!`;
  }
};

// Invoke the 'hello' method with arguments
invoke({ 
  method: 'hello', 
  args: ['World'], 
  target: targetObject 
}).then(result => {
  console.log(result); // Outputs: "Hello, World!"
}).catch(error => {
  console.error('Error:', error.message);
});
```

### Example 2: Handling Method Absence
In situations where the method might not exist on the target object, `@fnet/invoke` will throw an error. You can handle this gracefully using a `try-catch` block:

```javascript
import invoke from '@fnet/invoke';

const targetObject = {
  greet() {
    return 'Greetings!';
  }
};

try {
  const result = await invoke({ 
    method: 'nonExistentMethod', 
    target: targetObject 
  });
  console.log(result);
} catch (error) {
  console.error('Caught Error:', error.message); // Outputs: "Unsupported or invalid method: 'nonExistentMethod'"
}
```

## Examples
Below are additional examples showcasing the library's key capabilities:

### Example 3: Providing Arguments
You can pass arguments as an array to invoke methods requiring them:

```javascript
const mathOperations = {
  sum(a, b) {
    return a + b;
  }
};

invoke({ 
  method: 'sum', 
  args: [5, 10], 
  target: mathOperations 
}).then(result => {
  console.log(result); // Outputs: 15
});
```

### Example 4: Using with Async Methods
The library supports asynchronous methods, ensuring dynamic invocation remains seamless with `async/await`:

```javascript
const targetObject = {
  async fetchData(id) {
    // Simulate async operation
    return Promise.resolve(`Data for ID: ${id}`);
  }
};

invoke({
  method: 'fetchData',
  args: [42],
  target: targetObject
}).then(result => {
  console.log(result); // Outputs: "Data for ID: 42"
});
```

## Acknowledgement
This library is maintained by its author with contributions from the open-source community. Your feedback and contributions are always welcome, ensuring the library continues to improve.



# Input Schema
```yaml
$schema: https://json-schema.org/draft/2020-12/schema
type: object
properties:
  method:
    type: string
    description: The name of the method to invoke on the target object.
  args:
    type: array
    items:
      type: any
    description: An array of arguments to pass to the method.
    default: []
  target:
    type: object
    description: The target object containing the method to be invoked.
required:
  - method
  - target

```