Run npm run example
const Pluggable = require('./index')
/// A class extends Pluggable
class Foo extends Pluggable {
constructor () {
// need to call super.
super()
}
// a simple method, passing value
bar (a, b) {
return a + b
}
// a simple method, passing reference
foobar (obj) {
obj.name = 'foobar'
return obj
}
}
// wrap these methods
// 1. hook name is same as method name
Foo.wrapHook('bar', 'pre post')
// 2. hook name is custom
Foo.wrapHook('foobar', 'foo', 'pre post')
async function test (a, b, obj) {
try {
// add hooks before initialize instance.
// pre hook take all arguments as arguments.
// all hooks can be async.
Foo.pre('bar', function (a, b) {
console.log(`I'm the foo, and I am ${a} and ${b}.`)
})
// throw error to stop all plugins and the original call.
Foo.pre('bar', function (a, b) {
if (a === b) {
throw ReferenceError('Just an error')
}
})
/// post hook table result of original call.
Foo.post('bar', function (result) {
console.log(`I'm the foo, and I have a result ${result}.`)
})
// declare property before initialize instance.
Foo.declare('declareFoo', [1, 2, 3])
let foo = new Foo()
// add hooks after initialize class
Foo.pre('foo', function (obj) {
console.log(`I'm the foobar, and I am ${JSON.stringify(obj)}. I will add another field to ${JSON.stringify(obj)}`)
obj.anotherField = 'Plugin'
})
Foo.post('foo', function (result) {
console.log(`I'm the foobar, and I have a result ${JSON.stringify(result)}.`)
})
// wrapped methods become async functions.
return [await foo.bar(a, b), await foo.foobar(obj)]
} catch (error) {
console.error(error)
}
}
test(1, 2, {test: 1})
.then(result => {
console.log(`Finally, I get the result ${JSON.stringify(result)}`)
})
.then(() => {
return test(1, 1)
.catch(console.log)
})