161 lines
3.4 KiB
Plaintext
161 lines
3.4 KiB
Plaintext
|
/**
|
|||
|
|
* @typedef {(error?: Error|null|undefined, ...output: Array<any>) => void} Callback
|
|||
|
|
* @typedef {(...input: Array<any>) => any} Middleware
|
|||
|
|
*
|
|||
|
|
* @typedef {(...input: Array<any>) => void} Run
|
|||
|
|
* Call all middleware.
|
|||
|
|
* @typedef {(fn: Middleware) => Pipeline} Use
|
|||
|
|
* Add `fn` (middleware) to the list.
|
|||
|
|
* @typedef {{run: Run, use: Use}} Pipeline
|
|||
|
|
* Middleware.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Create new middleware.
|
|||
|
|
*
|
|||
|
|
* @returns {Pipeline}
|
|||
|
|
*/
|
|||
|
|
export function trough() {
|
|||
|
|
/** @type {Array<Middleware>} */
|
|||
|
|
const fns = []
|
|||
|
|
/** @type {Pipeline} */
|
|||
|
|
const pipeline = {run, use}
|
|||
|
|
|
|||
|
|
return pipeline
|
|||
|
|
|
|||
|
|
/** @type {Run} */
|
|||
|
|
function run(...values) {
|
|||
|
|
let middlewareIndex = -1
|
|||
|
|
/** @type {Callback} */
|
|||
|
|
const callback = values.pop()
|
|||
|
|
|
|||
|
|
if (typeof callback !== 'function') {
|
|||
|
|
throw new TypeError('Expected function as last argument, not ' + callback)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
next(null, ...values)
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Run the next `fn`, or we’re done.
|
|||
|
|
*
|
|||
|
|
* @param {Error|null|undefined} error
|
|||
|
|
* @param {Array<any>} output
|
|||
|
|
*/
|
|||
|
|
function next(error, ...output) {
|
|||
|
|
const fn = fns[++middlewareIndex]
|
|||
|
|
let index = -1
|
|||
|
|
|
|||
|
|
if (error) {
|
|||
|
|
callback(error)
|
|||
|
|
return
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Copy non-nullish input into values.
|
|||
|
|
while (++index < values.length) {
|
|||
|
|
if (output[index] === null || output[index] === undefined) {
|
|||
|
|
output[index] = values[index]
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Save the newly created `output` for the next call.
|
|||
|
|
values = output
|
|||
|
|
|
|||
|
|
// Next or done.
|
|||
|
|
if (fn) {
|
|||
|
|
wrap(fn, next)(...output)
|
|||
|
|
} else {
|
|||
|
|
callback(null, ...output)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/** @type {Use} */
|
|||
|
|
function use(middelware) {
|
|||
|
|
if (typeof middelware !== 'function') {
|
|||
|
|
throw new TypeError(
|
|||
|
|
'Expected `middelware` to be a function, not ' + middelware
|
|||
|
|
)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
fns.push(middelware)
|
|||
|
|
return pipeline
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Wrap `middleware`.
|
|||
|
|
* Can be sync or async; return a promise, receive a callback, or return new
|
|||
|
|
* values and errors.
|
|||
|
|
*
|
|||
|
|
* @param {Middleware} middleware
|
|||
|
|
* @param {Callback} callback
|
|||
|
|
*/
|
|||
|
|
export function wrap(middleware, callback) {
|
|||
|
|
/** @type {boolean} */
|
|||
|
|
let called
|
|||
|
|
|
|||
|
|
return wrapped
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Call `middleware`.
|
|||
|
|
* @this {any}
|
|||
|
|
* @param {Array<any>} parameters
|
|||
|
|
* @returns {void}
|
|||
|
|
*/
|
|||
|
|
function wrapped(...parameters) {
|
|||
|
|
const fnExpectsCallback = middleware.length > parameters.length
|
|||
|
|
/** @type {any} */
|
|||
|
|
let result
|
|||
|
|
|
|||
|
|
if (fnExpectsCallback) {
|
|||
|
|
parameters.push(done)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
try {
|
|||
|
|
result = middleware.apply(this, parameters)
|
|||
|
|
} catch (error) {
|
|||
|
|
const exception = /** @type {Error} */ (error)
|
|||
|
|
|
|||
|
|
// Well, this is quite the pickle.
|
|||
|
|
// `middleware` received a callback and called it synchronously, but that
|
|||
|
|
// threw an error.
|
|||
|
|
// The only thing left to do is to throw the thing instead.
|
|||
|
|
if (fnExpectsCallback && called) {
|
|||
|
|
throw exception
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return done(exception)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!fnExpectsCallback) {
|
|||
|
|
if (result instanceof Promise) {
|
|||
|
|
result.then(then, done)
|
|||
|
|
} else if (result instanceof Error) {
|
|||
|
|
done(result)
|
|||
|
|
} else {
|
|||
|
|
then(result)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Call `callback`, only once.
|
|||
|
|
* @type {Callback}
|
|||
|
|
*/
|
|||
|
|
function done(error, ...output) {
|
|||
|
|
if (!called) {
|
|||
|
|
called = true
|
|||
|
|
callback(error, ...output)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Call `done` with one value.
|
|||
|
|
*
|
|||
|
|
* @param {any} [value]
|
|||
|
|
*/
|
|||
|
|
function then(value) {
|
|||
|
|
done(null, value)
|
|||
|
|
}
|
|||
|
|
}
|