aaac7fed
 liuqimichale
add
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
# Tapable
``` javascript
var Tapable = require("tapable");
```
`Tapable` is a class for plugin binding and applying.
Just extend it.
``` javascript
function MyClass() {
Tapable.call(this);
}
MyClass.prototype = Object.create(Tapable.prototype);
MyClass.prototype.method = function() {};
```
Or mix it in.
``` javascript
function MyClass2() {
EventEmitter.call(this);
Tapable.call(this);
}
MyClass2.prototype = Object.create(EventEmitter.prototype);
Tapable.mixin(MyClass2.prototype);
MyClass2.prototype.method = function() {};
```
## Public functions
### apply
``` javascript
void apply(plugins: Plugin...)
```
Attaches all plugins passed as arguments to the instance, by calling `apply` on them.
### plugin
``` javascript
void plugin(names: string|string[], handler: Function)
```
`names` are the names (or a single name) of the plugin interfaces the class provides.
`handler` is a callback function. The signature depends on the class. `this` is the instance of the class.
## Protected functions
### applyPlugins
``` javascript
void applyPlugins(name: string, args: any...)
```
Synchronously applies all registered handlers for `name`. The handler functions are called with all args.
### applyPluginsWaterfall
``` javascript
any applyPluginsWaterfall(name: string, init: any, args: any...)
```
Synchronously applies all registered handlers for `name`. The handler functions are called with the return value of the previous handler and all args. For the first handler `init` is used and the return value of the last handler is return by `applyPluginsWaterfall`
### applyPluginsAsync
``` javascript
void applyPluginsAsync(
name: string,
args: any...,
callback: (err?: Error) -> void
)
```
Asynchronously applies all registered handlers for `name`. The handler functions are called with all args and a callback function with the signature `(err?: Error) -> void`. The handler functions are called in order of registration.
`callback` is called after all handlers are called.
### applyPluginsBailResult
``` javascript
any applyPluginsBailResult(name: string, args: any...)
```
Synchronously applies all registered handlers for `name`. The handler function are called with all args. If a handler function returns something `!== undefined`, the value is returned and no more handlers are applied.
### applyPluginsAsyncWaterfall
``` javascript
applyPluginsAsyncWaterfall(
name: string,
init: any,
callback: (err: Error, result: any) -> void
)
```
Asynchronously applies all registered handlers for `name`. The handler functions are called with the current value and a callback function with the signature `(err: Error, nextValue: any) -> void`. When called, `nextValue` is the current value for the next handler. The current value for the first handler is `init`. After all handlers are applied, `callback` is called with the last value. If any handler passes a value for `err`, the `callback` is called with this error and no more handlers are called.
### applyPluginsAsyncSeries
``` javascript
applyPluginsAsyncSeries(
name: string,
args: any...,
callback: (err: Error, result: any) -> void
)
```
Asynchronously applies all registered handlers for `name`. The handler functions are called with all `args` and a callback function with the signature `(err: Error) -> void`. The handlers are called in series, one at a time. After all handlers are applied, `callback` is called. If any handler passes a value for `err`, the `callback` is called with this error and no more handlers are called.
### applyPluginsParallel
``` javascript
applyPluginsParallel(
name: string,
args: any...,
callback: (err?: Error) -> void
)
```
Applies all registered handlers for `name` in parallel. The handler functions are called with all args and a callback function with the signature `(err?: Error) -> void`. The `callback` function is called when all handlers have called the callback without `err`. If any handler calls the callback with `err`, `callback` is invoked with this error and the other handlers are ignored.
### applyPluginsParallelBailResult
``` javascript
applyPluginsParallelBailResult(
name: string,
args: any...,
callback: (err: Error, result: any) -> void
)
```
Applies all registered handlers for `name` in parallel. The handler functions are called with all args and a callback function with the signature `(err?: Error) -> void`. Handler functions must call the callback. They can either pass an error, pass undefined, or pass a value. The first result (either error or value) which is not undefined is passed to the `callback`. The order is defined by registration, not by the speed of the handler function.
### hasPlugins
``` js
hasPlugins(
name: string
)
```
Returns true, if plugins are registered for this name.
|
