Plugin-anything NPM

Inroduction

Make pluginable applications.

How does it work ?

Demo

// Custom Plugins
class CustomPluginA {
    constructor(options) {
        console.log('CustomPluginA options', options);
    }

    apply(customApp) {
        customApp.hooks.hookA.tap('my plugin A', async (data) => {
            console.log('CustomPluginA runs', data);
            return 'a';
        });
    }
}

class CustomPluginB {
    constructor(options) {
        console.log('CustomPluginB options', options);
    }

    apply(customApp) {
        customApp.hooks.hookB.tap('my plugin B', async (data) => {
            console.log('CustomPluginB runs', data);
        });
    }
}

// Custom App
const { PluginAnything } = require('plugin-anything');
class CustomApp extends PluginAnything {
    constructor() {
        super();

        // define hooks for plugin using
        this.hooks = {
            hookA: this.createHook(), // 'createHook' inherits from PluginAnything
            hookB: this.createHook(), // 'createHook' inherits from PluginAnything
        }

        this.install({
            plugins: [ CustomPluginA, CustomPluginB ],
        })

        (async () => {
            // mock wait 2s
            await new Promise(resolve => setTimeout(resolve, 2000))
            await this.hooks.hookA.flush();

            // mock wait 2s
            await new Promise(resolve => setTimeout(resolve, 2000))
            await this.hooks.hookB.flush();
        })()
    }

    hooks = null;
}

new CustomApp();

CustomPluginA options {}
CustomPluginB options {}

# wait 2s
CustomPluginA runs
# wait 2s
CustomPluginB runs

APIs

const pluginAnything = new PluginAnything(options: { [name: string]: any });

Hook Handler: `pluginAnything.createHook()`

const hook = createHook();

create a hook.

hook.tap(name: string, callback: Function | Promise<any>)
Add callback at current hook event.
name could be any string for event description.
hook.untap(name?: string)
Remove callback list whose name equals name.
When name is blank, clear callback list.
hook.flush(type?: sync | waterfall | paralle, initData?: skip = false, paralleLimit = 3)
Run all callbacks.
- sync (default)
  run callbacks one next one.
- waterfall
  run callbacks one next none.
  and previous returned value will be parameter of next callback.
- paralle
  run all callbacks at the same time.
- paralle-sync
  run callbacks by sync sequences:
```
[ callback1, callback2, cakkback3 ]

[ callback4, ... ]

...
```

hook.beforeFlush(callback) and hook.afterFlush(callback)

regist callback before and after flush.

callback should be a Function with return type any | Promise<any>.

example:

(async () => {
    hook.beforeFlush(async () => {
        console.log('before flush');
    });

    hook.afterFlush(async () => {
        console.log('after flush');
    });

    await hook.flush();
})();

// result
log: before flush

flushing...

log: after flush

Plugins Handler: `pluginAnything.install(initOptions: typeInitOptions): Array<{ [name: string]: any }>`

interface typeInitOptions {
    searchList?: Array<string>;
    plugins?: Array<string | Function | object | Array<any>>;
    presets?: Array<string | Array<any>>;
}

Install plugins and return plugin list.

initOptions.searchList: Array< string >
Absolute folder path list that will be used in searching plugins.
examples:
```
[
    '/path_a/node_modules',
    '/path_b/node_modules'
]
```
initOptions.plugins: Array< string | FunctionContructor | { apply(data?: any): any; [ name: string ]: any } | Array<string | FunctionContructor, object> >
```
class MyPlugin {
    constructor(options) {
        this.options = options;
    };

    options: {};

    apply(pa) {

    }
}
```

// config demo
plugins: {
    'my-plugin-0',

    [ 'my-plugin-1', { params: 1 } ],

    [ MyPlugin, { params: 2 } ],

    new MyPlugin({ params: 2 })
}
```