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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
/**
* @author Titus Wormer
* @copyright 2016 Titus Wormer
* @license MIT
* @module trough
* @fileoverview Middleware. Inspired by `segmentio/ware`,
* but able to change the values from transformer to
* transformer.
*/
'use strict';
/* Expose. */
module.exports = trough;
/* Methods. */
var slice = [].slice;
/**
* Create new middleware.
*
* @return {Object} - Middlewre.
*/
function trough() {
var fns = [];
var middleware = {};
middleware.run = run;
middleware.use = use;
return middleware;
/**
* Run `fns`. Last argument must be
* a completion handler.
*
* @param {...*} input - Parameters
*/
function run() {
var index = -1;
var input = slice.call(arguments, 0, -1);
var done = arguments[arguments.length - 1];
if (typeof done !== 'function') {
throw new Error('Expected function as last argument, not ' + done);
}
next.apply(null, [null].concat(input));
return;
/**
* Run the next `fn`, if any.
*
* @param {Error?} err - Failure.
* @param {...*} values - Other input.
*/
function next(err) {
var fn = fns[++index];
var params = slice.call(arguments, 0);
var values = params.slice(1);
var length = input.length;
var pos = -1;
if (err) {
done(err);
return;
}
/* Copy non-nully input into values. */
while (++pos < length) {
if (values[pos] === null || values[pos] === undefined) {
values[pos] = input[pos];
}
}
input = values;
/* Next or done. */
if (fn) {
wrap(fn, next).apply(null, input);
} else {
done.apply(null, [null].concat(input));
}
}
}
/**
* Add `fn` to the list.
*
* @param {Function} fn - Anything `wrap` accepts.
*/
function use(fn) {
if (typeof fn !== 'function') {
throw new Error('Expected `fn` to be a function, not ' + fn);
}
fns.push(fn);
return middleware;
}
}
/**
* Wrap `fn`. Can be sync or async; return a promise,
* receive a completion handler, return new values and
* errors.
*
* @param {Function} fn - Thing to wrap.
* @param {Function} next - Completion handler.
* @return {Function} - Wrapped `fn`.
*/
function wrap(fn, next) {
var invoked;
return wrapped;
function wrapped() {
var params = slice.call(arguments, 0);
var callback = fn.length > params.length;
var result;
if (callback) {
params.push(done);
}
try {
result = fn.apply(null, params);
} catch (err) {
/* Well, this is quite the pickle. `fn` received
* a callback and invoked it (thus continuing the
* pipeline), but later also threw an error.
* We’re not about to restart the pipeline again,
* so the only thing left to do is to throw the
* thing instea. */
if (callback && invoked) {
throw err;
}
return done(err);
}
if (!callback) {
if (result && typeof result.then === 'function') {
result.then(then, done);
} else if (result instanceof Error) {
done(result);
} else {
then(result);
}
}
}
/**
* Invoke `next`, only once.
*
* @param {Error?} err - Optional error.
*/
function done() {
if (!invoked) {
invoked = true;
next.apply(null, arguments);
}
}
/**
* Invoke `done` with one value.
* Tracks if an error is passed, too.
*
* @param {*} value - Optional value.
*/
function then(value) {
done(null, value);
}
}
|
