@orion76/ng-plugin

🇷🇺 Описание | 🇨🇳 说明

A library for implementing the Plugin architectural pattern in Angular applications

Base cross-platform library: @orion76/plugin

The idea for the Plugin library was borrowed from CMF Drupal 8 and adapted for Angular.

Table of Contents

• Overview
• Benefits
• Installation
• Links
• Usage Example
• Main Purpose
• Terms and Definitions
• External Classes and Interfaces

Overview

• Integration of the Plugin pattern into Angular applications.
• Allows you to separate the application into independent layers with minimal coupling.
• Simplifies plugin implementation and management.
• Increases modularity and extensibility of applications.

Benefits

• Clean architecture and modularity.
• Easy extension of functionality without changing the core.
• Simple integration with Angular 2+.

Installation

npm install --save @orion76/ng-plugin

Links

• Base library: @orion76/plugin
• Integration example: @orion76/ng-logger

Usage Example

import { NgPluginBase, PluginManagerDefaultService } from '@orion76/ng-plugin';

// Plugin definition
@NgPlugin({
  id: 'my-plugin',
  type: 'MY_PLUGIN_TYPE',
  label: 'My Plugin'
})
export class MyPlugin extends NgPluginBase {
  // ...plugin logic...
}

// Using the plugin manager
const manager = new PluginManagerDefaultService();
const plugin = manager.getInstance('my-plugin');
plugin?.someMethod();

Main Purpose

A ready-made solution for implementing the Plugin pattern and separating the application into layers:

1. Infrastructure layer
2. Enterprise business logic layer

Terms and Definitions

• Plugin — an independent module that implements specific functionality and can be connected to the main system without changing its core.
• Plugin definition — a configuration object describing the properties, type, identifier, and class of a plugin. Used for registration and lookup.
• Plugin manager — the central component for registering, finding, creating, and managing plugin instances.
• Plugin instance — an object created based on a plugin definition and implementing its logic.
• Deriver — a helper class for creating derivative plugins based on a base definition.
• Plugin builder — a component for creating plugin instances from definitions with DI support.
• Plugin discovery — a mechanism for finding and providing plugin definitions to the manager.

External Classes and Interfaces

Interface "IPluginDefinition"

interface IPluginDefinition<P extends IPlugin = IPlugin, D extends object = object> {
  type: string;
  id: string;
  label: string;
  pluginClass?: IType<P>;
  deriverClass?: IType<IPluginDeriver<D>>;
  disabled?: boolean;
}

Interface "IPlugin"

interface IPlugin {
  type: string;
  id: string;
  label: string;
  definition: IPluginDefinition;
}

Interface "IPluginManager"

export interface IPluginManager<P extends IPlugin = IPlugin> {
  getDefinition(id: string): P['definition'] | undefined;
  getDefinitions(): P['definition'][];
  getInstance(id: string): P;
}

In short: the application service receives a plugin manager of a specific type as a dependency, selects the required plugin by definition, and calls its methods.