| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/openskillpaths/node_modules/avvio/lib/ |
Upload File : |
'use strict'
const { EventEmitter } = require('node:events')
const { inherits } = require('node:util')
const { debug } = require('./debug')
const { createPromise } = require('./create-promise')
const { AVV_ERR_PLUGIN_EXEC_TIMEOUT } = require('./errors')
const { getPluginName } = require('./get-plugin-name')
const { isPromiseLike } = require('./is-promise-like')
/**
* @param {*} queue
* @param {*} func
* @param {*} options
* @param {boolean} isAfter
* @param {number} [timeout]
*/
function Plugin (queue, func, options, isAfter, timeout) {
this.queue = queue
this.func = func
this.options = options
/**
* @type {boolean}
*/
this.isAfter = isAfter
/**
* @type {number}
*/
this.timeout = timeout
/**
* @type {boolean}
*/
this.started = false
/**
* @type {string}
*/
this.name = getPluginName(func, options)
this.queue.pause()
/**
* @type {Error|null}
*/
this._error = null
/**
* @type {boolean}
*/
this.loaded = false
this._promise = null
this.startTime = null
}
inherits(Plugin, EventEmitter)
/**
* @callback ExecCallback
* @param {Error|null} execErr
* @returns
*/
/**
*
* @param {*} server
* @param {ExecCallback} callback
* @returns
*/
Plugin.prototype.exec = function (server, callback) {
debug('exec', this.name)
this.server = server
const func = this.func
const name = this.name
let completed = false
this.options = typeof this.options === 'function' ? this.options(this.server) : this.options
let timer = null
/**
* @param {Error} [execErr]
*/
const done = (execErr) => {
if (completed) {
debug('loading complete', name)
return
}
this._error = execErr
if (execErr) {
debug('exec errored', name)
} else {
debug('exec completed', name)
}
completed = true
if (timer) {
clearTimeout(timer)
}
callback(execErr)
}
if (this.timeout > 0) {
debug('setting up timeout', name, this.timeout)
timer = setTimeout(function () {
debug('timed out', name)
timer = null
const readyTimeoutErr = new AVV_ERR_PLUGIN_EXEC_TIMEOUT(name)
// TODO Remove reference to function
readyTimeoutErr.fn = func
done(readyTimeoutErr)
}, this.timeout)
}
this.started = true
this.startTime = Date.now()
this.emit('start', this.server ? this.server.name : null, this.name, Date.now())
const maybePromiseLike = func(this.server, this.options, done)
if (isPromiseLike(maybePromiseLike)) {
debug('exec: resolving promise', name)
maybePromiseLike.then(
() => process.nextTick(done),
(e) => process.nextTick(done, e))
} else if (func.length < 3) {
done()
}
}
/**
* @returns {Promise}
*/
Plugin.prototype.loadedSoFar = function () {
debug('loadedSoFar', this.name)
if (this.loaded) {
return Promise.resolve()
}
const setup = () => {
this.server.after((afterErr, callback) => {
this._error = afterErr
this.queue.pause()
if (this._promise) {
if (afterErr) {
debug('rejecting promise', this.name, afterErr)
this._promise.reject(afterErr)
} else {
debug('resolving promise', this.name)
this._promise.resolve()
}
this._promise = null
}
process.nextTick(callback, afterErr)
})
this.queue.resume()
}
let res
if (!this._promise) {
this._promise = createPromise()
res = this._promise.promise
if (!this.server) {
this.on('start', setup)
} else {
setup()
}
} else {
res = Promise.resolve()
}
return res
}
/**
* @callback EnqueueCallback
* @param {Error|null} enqueueErr
* @param {Plugin} result
*/
/**
*
* @param {Plugin} plugin
* @param {EnqueueCallback} callback
*/
Plugin.prototype.enqueue = function (plugin, callback) {
debug('enqueue', this.name, plugin.name)
this.emit('enqueue', this.server ? this.server.name : null, this.name, Date.now())
this.queue.push(plugin, callback)
}
/**
* @callback FinishCallback
* @param {Error|null} finishErr
* @returns
*/
/**
*
* @param {Error|null} err
* @param {FinishCallback} callback
* @returns
*/
Plugin.prototype.finish = function (err, callback) {
debug('finish', this.name, err)
const done = () => {
if (this.loaded) {
return
}
debug('loaded', this.name)
this.emit('loaded', this.server ? this.server.name : null, this.name, Date.now())
this.loaded = true
callback(err)
}
if (err) {
if (this._promise) {
this._promise.reject(err)
this._promise = null
}
done()
return
}
const check = () => {
debug('check', this.name, this.queue.length(), this.queue.running(), this._promise)
if (this.queue.length() === 0 && this.queue.running() === 0) {
if (this._promise) {
const wrap = () => {
debug('wrap')
queueMicrotask(check)
}
this._promise.resolve()
this._promise.promise.then(wrap, wrap)
this._promise = null
} else {
done()
}
} else {
debug('delayed', this.name)
// finish when the queue of nested plugins to load is empty
this.queue.drain = () => {
debug('drain', this.name)
this.queue.drain = noop
// we defer the check, as a safety net for things
// that might be scheduled in the loading callback
queueMicrotask(check)
}
}
}
queueMicrotask(check)
// we start loading the dependents plugins only once
// the current level is finished
this.queue.resume()
}
function noop () {}
module.exports = {
Plugin
}