hexo/node_modules/diagnostics_channel/index.js

157 lines
3.5 KiB
JavaScript
Raw Normal View History

2023-09-25 15:58:56 +08:00
'use strict';
const util = require('util');
// Port from node core lib/internal/errors.js
class ERR_INVALID_ARG_TYPE extends TypeError {
constructor(message, actual) {
super();
if (actual == null) {
message += `. Received ${actual}`;
} else if (typeof actual === 'function' && actual.name) {
message += `. Received function ${actual.name}`;
} else if (typeof actual === 'object') {
if (actual.constructor && actual.constructor.name) {
message += `. Received an instance of ${actual.constructor.name}`;
} else {
const inspected = util.inspect(actual, { depth: -1 });
message += `. Received ${inspected}`;
}
} else {
let inspected = util.inspect(actual, { colors: false });
if (inspected.length > 25) {
inspected = `${inspected.slice(0, 25)}...`;
}
message += `. Received type ${typeof actual} (${inspected})`;
}
this.code = this.constructor.name;
Object.defineProperties(this, {
message: {
value: message,
enumerable: false,
writable: true,
configurable: true,
},
toString: {
value() {
return `${this.name} [${this.code}]: ${this.message}`;
},
enumerable: false,
writable: true,
configurable: true,
},
});
}
}
class ActiveChannel {
subscribe(subscription) {
if (typeof subscription !== 'function') {
throw new ERR_INVALID_ARG_TYPE('The "subscription" argument must be of type function', subscription);
}
this._subscribers.push(subscription);
}
unsubscribe(subscription) {
const index = this._subscribers.indexOf(subscription);
if (index === -1) return false;
this._subscribers.splice(index, 1);
// When there are no more active subscribers, restore to fast prototype.
if (!this._subscribers.length) {
// eslint-disable-next-line no-use-before-define
Object.setPrototypeOf(this, Channel.prototype);
}
return true;
}
get hasSubscribers() {
return true;
}
publish(data) {
for (let i = 0; i < this._subscribers.length; i++) {
try {
const onMessage = this._subscribers[i];
onMessage(data, this.name);
} catch (err) {
process.nextTick(() => {
throw err;
});
}
}
}
}
class Channel {
constructor(name) {
this._subscribers = undefined;
this.name = name;
}
static [Symbol.hasInstance](instance) {
const prototype = Object.getPrototypeOf(instance);
return prototype === Channel.prototype ||
prototype === ActiveChannel.prototype;
}
subscribe(subscription) {
Object.setPrototypeOf(this, ActiveChannel.prototype);
this._subscribers = [];
this.subscribe(subscription);
}
unsubscribe() {
return false;
}
get hasSubscribers() {
return false;
}
publish() {}
}
const channels = {};
function channel(name) {
const channel = channels[name];
if (channel) return channel;
if (typeof name !== 'string' && typeof name !== 'symbol') {
throw new ERR_INVALID_ARG_TYPE('The "channel" argument must be one of type string or symbol', name);
}
return channels[name] = new Channel(name);
}
function hasSubscribers(name) {
const channel = channels[name];
if (!channel) {
return false;
}
return channel.hasSubscribers;
}
function deleteChannel(name) {
if (channels[name]) {
channels[name] = null;
return true;
}
return false;
}
module.exports = {
channel,
hasSubscribers,
Channel,
deleteChannel
};