robojerk/codeql-action

Bump packages to fix linter

Browse source
This commit is contained in:
Henry Mercer 2023-01-18 20:50:03 +00:00
parent ed9506bbaf
commit 0a11e3fdd9
6063 changed files with 378752 additions and 306784 deletions
Download patch file Download diff file Expand all files Collapse all files

199
node_modules/emittery/index.js generated vendored
View file

@ -1,8 +1,5 @@
'use strict';
import {anyMap, producersMap, eventsMap} from './maps.js';
const anyMap = new WeakMap();
const eventsMap = new WeakMap();
const producersMap = new WeakMap();
const anyProducer = Symbol('anyProducer');
const resolvedPromise = Promise.resolve();
@ -10,19 +7,13 @@ const resolvedPromise = Promise.resolve();
const listenerAdded = Symbol('listenerAdded');
const listenerRemoved = Symbol('listenerRemoved');
// Define a symbol that allows internal code to emit meta events, but prevents userland from doing so.
const metaEventsAllowed = Symbol('metaEventsAllowed');
let canEmitMetaEvents = false;
let isGlobalDebugEnabled = false;
function assertEventName(eventName, allowMetaEvents) {
function assertEventName(eventName) {
if (typeof eventName !== 'string' && typeof eventName !== 'symbol' && typeof eventName !== 'number') {
throw new TypeError('`eventName` must be a string, symbol, or number');
}
if (isMetaEvent(eventName) && allowMetaEvents !== metaEventsAllowed) {
throw new TypeError('`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`');
}
}
function assertListener(listener) {
@ -34,7 +25,7 @@ function assertListener(listener) {
function getListeners(instance, eventName) {
const events = eventsMap.get(instance);
if (!events.has(eventName)) {
events.set(eventName, new Set());
return;
}
return events.get(eventName);
@ -44,7 +35,7 @@ function getEventProducers(instance, eventName) {
const key = typeof eventName === 'string' || typeof eventName === 'symbol' || typeof eventName === 'number' ? eventName : anyProducer;
const producers = producersMap.get(instance);
if (!producers.has(key)) {
producers.set(key, new Set());
return;
}
return producers.get(key);
@ -81,11 +72,18 @@ function iterator(instance, eventNames) {
finish() {
isFinished = true;
flush();
}
},
};
for (const eventName of eventNames) {
getEventProducers(instance, eventName).add(producer);
let set = getEventProducers(instance, eventName);
if (!set) {
set = new Set();
const producers = producersMap.get(instance);
producers.set(eventName, set);
}
set.add(producer);
}
return {
@ -109,7 +107,7 @@ function iterator(instance, eventNames) {
return {
done: false,
value: await queue.shift()
value: await queue.shift(),
};
},
@ -117,19 +115,26 @@ function iterator(instance, eventNames) {
queue = undefined;
for (const eventName of eventNames) {
getEventProducers(instance, eventName).delete(producer);
const set = getEventProducers(instance, eventName);
if (set) {
set.delete(producer);
if (set.size === 0) {
const producers = producersMap.get(instance);
producers.delete(eventName);
}
}
}
flush();
return arguments.length > 0 ?
{done: true, value: await value} :
{done: true};
return arguments.length > 0
? {done: true, value: await value}
: {done: true};
},
[Symbol.asyncIterator]() {
return this;
}
},
};
}
@ -157,7 +162,18 @@ function defaultMethodNamesOrAssert(methodNames) {
const isMetaEvent = eventName => eventName === listenerAdded || eventName === listenerRemoved;
class Emittery {
function emitMetaEvent(emitter, eventName, eventData) {
if (isMetaEvent(eventName)) {
try {
canEmitMetaEvents = true;
emitter.emit(eventName, eventData);
} finally {
canEmitMetaEvents = false;
}
}
}
export default class Emittery {
static mixin(emitteryPropertyName, methodNames) {
methodNames = defaultMethodNamesOrAssert(methodNames);
return target => {
@ -174,14 +190,14 @@ class Emittery {
function getEmitteryProperty() {
Object.defineProperty(this, emitteryPropertyName, {
enumerable: false,
value: new Emittery()
value: new Emittery(),
});
return this[emitteryPropertyName];
}
Object.defineProperty(target.prototype, emitteryPropertyName, {
enumerable: false,
get: getEmitteryProperty
get: getEmitteryProperty,
});
const emitteryMethodCaller = methodName => function (...args) {
@ -191,7 +207,7 @@ class Emittery {
for (const methodName of methodNames) {
Object.defineProperty(target.prototype, methodName, {
enumerable: false,
value: emitteryMethodCaller(methodName)
value: emitteryMethodCaller(methodName),
});
}
@ -200,11 +216,15 @@ class Emittery {
}
static get isDebugEnabled() {
if (typeof process !== 'object') {
// In a browser environment, `globalThis.process` can potentially reference a DOM Element with a `#process` ID,
// so instead of just type checking `globalThis.process`, we need to make sure that `globalThis.process.env` exists.
// eslint-disable-next-line n/prefer-global/process
if (typeof globalThis.process?.env !== 'object') {
return isGlobalDebugEnabled;
}
const {env} = process || {env: {}};
// eslint-disable-next-line n/prefer-global/process
const {env} = globalThis.process ?? {env: {}};
return env.DEBUG === 'emittery' || env.DEBUG === '*' || isGlobalDebugEnabled;
}
@ -216,7 +236,10 @@ class Emittery {
anyMap.set(this, new Set());
eventsMap.set(this, new Map());
producersMap.set(this, new Map());
this.debug = options.debug || {};
producersMap.get(this).set(anyProducer, new Set());
this.debug = options.debug ?? {};
if (this.debug.enabled === undefined) {
this.debug.enabled = false;
@ -253,13 +276,20 @@ class Emittery {
eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
for (const eventName of eventNames) {
assertEventName(eventName, metaEventsAllowed);
getListeners(this, eventName).add(listener);
assertEventName(eventName);
let set = getListeners(this, eventName);
if (!set) {
set = new Set();
const events = eventsMap.get(this);
events.set(eventName, set);
}
set.add(listener);
this.logIfDebugEnabled('subscribe', eventName, undefined);
if (!isMetaEvent(eventName)) {
this.emit(listenerAdded, {eventName, listener}, metaEventsAllowed);
emitMetaEvent(this, listenerAdded, {eventName, listener});
}
}
@ -271,43 +301,59 @@ class Emittery {
eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
for (const eventName of eventNames) {
assertEventName(eventName, metaEventsAllowed);
getListeners(this, eventName).delete(listener);
assertEventName(eventName);
const set = getListeners(this, eventName);
if (set) {
set.delete(listener);
if (set.size === 0) {
const events = eventsMap.get(this);
events.delete(eventName);
}
}
this.logIfDebugEnabled('unsubscribe', eventName, undefined);
if (!isMetaEvent(eventName)) {
this.emit(listenerRemoved, {eventName, listener}, metaEventsAllowed);
emitMetaEvent(this, listenerRemoved, {eventName, listener});
}
}
}
once(eventNames) {
return new Promise(resolve => {
const off = this.on(eventNames, data => {
off();
let off_;
const promise = new Promise(resolve => {
off_ = this.on(eventNames, data => {
off_();
resolve(data);
});
});
promise.off = off_;
return promise;
}
events(eventNames) {
eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
for (const eventName of eventNames) {
assertEventName(eventName, metaEventsAllowed);
assertEventName(eventName);
}
return iterator(this, eventNames);
}
async emit(eventName, eventData, allowMetaEvents) {
assertEventName(eventName, allowMetaEvents);
async emit(eventName, eventData) {
assertEventName(eventName);
if (isMetaEvent(eventName) && !canEmitMetaEvents) {
throw new TypeError('`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`');
}
this.logIfDebugEnabled('emit', eventName, eventData);
enqueueProducers(this, eventName, eventData);
const listeners = getListeners(this, eventName);
const listeners = getListeners(this, eventName) ?? new Set();
const anyListeners = anyMap.get(this);
const staticListeners = [...listeners];
const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners];
@ -323,16 +369,20 @@ class Emittery {
if (anyListeners.has(listener)) {
return listener(eventName, eventData);
}
})
}),
]);
}
async emitSerial(eventName, eventData, allowMetaEvents) {
assertEventName(eventName, allowMetaEvents);
async emitSerial(eventName, eventData) {
assertEventName(eventName);
if (isMetaEvent(eventName) && !canEmitMetaEvents) {
throw new TypeError('`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`');
}
this.logIfDebugEnabled('emitSerial', eventName, eventData);
const listeners = getListeners(this, eventName);
const listeners = getListeners(this, eventName) ?? new Set();
const anyListeners = anyMap.get(this);
const staticListeners = [...listeners];
const staticAnyListeners = [...anyListeners];
@ -359,7 +409,7 @@ class Emittery {
this.logIfDebugEnabled('subscribeAny', undefined, undefined);
anyMap.get(this).add(listener);
this.emit(listenerAdded, {listener}, metaEventsAllowed);
emitMetaEvent(this, listenerAdded, {listener});
return this.offAny.bind(this, listener);
}
@ -372,7 +422,7 @@ class Emittery {
this.logIfDebugEnabled('unsubscribeAny', undefined, undefined);
this.emit(listenerRemoved, {listener}, metaEventsAllowed);
emitMetaEvent(this, listenerRemoved, {listener});
anyMap.get(this).delete(listener);
}
@ -383,29 +433,35 @@ class Emittery {
this.logIfDebugEnabled('clear', eventName, undefined);
if (typeof eventName === 'string' || typeof eventName === 'symbol' || typeof eventName === 'number') {
getListeners(this, eventName).clear();
const set = getListeners(this, eventName);
if (set) {
set.clear();
}
const producers = getEventProducers(this, eventName);
for (const producer of producers) {
producer.finish();
}
producers.clear();
} else {
anyMap.get(this).clear();
for (const listeners of eventsMap.get(this).values()) {
listeners.clear();
}
for (const producers of producersMap.get(this).values()) {
if (producers) {
for (const producer of producers) {
producer.finish();
}
producers.clear();
}
} else {
anyMap.get(this).clear();
for (const [eventName, listeners] of eventsMap.get(this).entries()) {
listeners.clear();
eventsMap.get(this).delete(eventName);
}
for (const [eventName, producers] of producersMap.get(this).entries()) {
for (const producer of producers) {
producer.finish();
}
producers.clear();
producersMap.get(this).delete(eventName);
}
}
}
}
@ -416,13 +472,16 @@ class Emittery {
for (const eventName of eventNames) {
if (typeof eventName === 'string') {
count += anyMap.get(this).size + getListeners(this, eventName).size +
getEventProducers(this, eventName).size + getEventProducers(this).size;
count += anyMap.get(this).size
+ (getListeners(this, eventName)?.size ?? 0)
+ (getEventProducers(this, eventName)?.size ?? 0)
+ (getEventProducers(this)?.size ?? 0);
continue;
}
if (typeof eventName !== 'undefined') {
assertEventName(eventName, metaEventsAllowed);
assertEventName(eventName);
}
count += anyMap.get(this).size;
@ -453,7 +512,7 @@ class Emittery {
Object.defineProperty(target, methodName, {
enumerable: false,
value: this[methodName].bind(this)
value: this[methodName].bind(this),
});
}
}
@ -465,13 +524,11 @@ Object.defineProperty(Emittery, 'listenerAdded', {
value: listenerAdded,
writable: false,
enumerable: true,
configurable: false
configurable: false,
});
Object.defineProperty(Emittery, 'listenerRemoved', {
value: listenerRemoved,
writable: false,
enumerable: true,
configurable: false
configurable: false,
});
module.exports = Emittery;