AbstractOptionalblobOptionaldateOptionaldateOptionalisOptionalisOptionalutcProtectedbeccaProtected_getProtected_setProtectedbeforeOptionalopts: {}OptionalisDeleted: booleanAbstractgetProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
+This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
+Optionalopts: {}AbstractupdateThe class AsyncResource is designed to be extended by the embedder's async
+resources. Using this, users can easily trigger the lifetime events of their
+own resources.
The init hook will trigger when an AsyncResource is instantiated.
The following is an overview of the AsyncResource API.
import { AsyncResource, executionAsyncId } from 'node:async_hooks';
// AsyncResource() is meant to be extended. Instantiating a
// new AsyncResource() also triggers init. If triggerAsyncId is omitted then
// async_hook.executionAsyncId() is used.
const asyncResource = new AsyncResource(
type, { triggerAsyncId: executionAsyncId(), requireManualDestroy: false },
);
// Run a function in the execution context of the resource. This will
// * establish the context of the resource
// * trigger the AsyncHooks before callbacks
// * call the provided function `fn` with the supplied arguments
// * trigger the AsyncHooks after callbacks
// * restore the original execution context
asyncResource.runInAsyncScope(fn, thisArg, ...args);
// Call AsyncHooks destroy callbacks.
asyncResource.emitDestroy();
// Return the unique ID assigned to the AsyncResource instance.
asyncResource.asyncId();
// Return the trigger ID for the AsyncResource instance.
asyncResource.triggerAsyncId();
+AsyncResource() is meant to be extended. Instantiating a +new AsyncResource() also triggers init. If triggerAsyncId is omitted then +async_hook.executionAsyncId() is used.
+The type of async event.
+OptionaltriggerAsyncId: number | AsyncResourceOptionsThe ID of the execution context that created
+this async event (default: executionAsyncId()), or an
+AsyncResourceOptions object (since v9.3.0)
The unique asyncId assigned to the resource.
Call all destroy hooks. This should only ever be called once. An error will
+be thrown if it is called more than once. This must be manually called. If
+the resource is left to be collected by the GC then the destroy hooks will
+never be called.
A reference to asyncResource.
Call the provided function with the provided arguments in the execution context +of the async resource. This will establish the context, trigger the AsyncHooks +before callbacks, call the function, trigger the AsyncHooks after callbacks, and +then restore the original execution context.
+The same triggerAsyncId that is passed to the AsyncResource constructor.
StaticbindOptionalconfig: AxiosRequestConfig<any>Optionalconfig: AxiosRequestConfig<D>Optionalconfig: AxiosRequestConfig<D>Optionalconfig: AxiosRequestConfig<any>Optionalconfig: AxiosRequestConfig<D>Optionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionalmessage: stringOptionalcode: stringOptionalconfig: InternalAxiosRequestConfig<D>Optionalrequest: anyOptionalresponse: AxiosResponse<T, D>OptionalcauseOptionalcodeOptionalconfigOptionalrequestOptionalresponseOptionalstackOptionalstatusStatic ReadonlyECONNABORTEDStatic ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyETIMEDOUTStatic OptionalprepareOptional override for formatting stack traces
+StaticstackStaticcaptureCreate .stack property on a target object
+OptionalconstructorOpt: FunctionStaticfromOptionalcode: stringOptionalconfig: InternalAxiosRequestConfig<D>Optionalrequest: anyOptionalresponse: AxiosResponse<T, D>OptionalcustomProps: objectOptionalheaders: string | AxiosHeaders | RawAxiosHeadersOptionalmatcher: AxiosHeaderMatcherOptionalmatcher: AxiosHeaderMatcherOptionalmatcher: true | AxiosHeaderParserOptionalparser: RegExpOptionalmatcher: AxiosHeaderMatcherOptionalparser: RegExpOptionalmatcher: AxiosHeaderMatcherOptionalparser: RegExpOptionalmatcher: AxiosHeaderMatcherOptionalparser: RegExpOptionalmatcher: AxiosHeaderMatcherOptionalparser: RegExpOptionalmatcher: AxiosHeaderMatcherOptionalparser: RegExpOptionalmatcher: AxiosHeaderMatcherOptionalmatcher: AxiosHeaderMatcherOptionalmatcher: AxiosHeaderMatcherOptionalmatcher: AxiosHeaderMatcherOptionalmatcher: AxiosHeaderMatcherOptionalmatcher: AxiosHeaderMatcherOptionalmatcher: AxiosHeaderMatcherOptionalmatcher: AxiosHeaderMatcherOptionalheaderName: stringOptionalvalue: AxiosHeaderValueOptionalrewrite: boolean | AxiosHeaderMatcherOptionalheaders: string | AxiosHeaders | RawAxiosHeadersOptionalrewrite: booleanOptionalrewrite: boolean | AxiosHeaderMatcherOptionalrewrite: boolean | AxiosHeaderMatcherOptionalrewrite: boolean | AxiosHeaderMatcherOptionalrewrite: boolean | AxiosHeaderMatcherOptionalrewrite: boolean | AxiosHeaderMatcherOptionalrewrite: boolean | AxiosHeaderMatcherOptionalasStrings: booleanStaticaccessorStaticconcatStaticfromOptionalthing: string | AxiosHeaders | RawAxiosHeadersAttachment represent data related/attached to the note. Conceptually similar to attributes, but intended for +larger amounts of data and generally not accessible to the user.
+OptionalattachmentOptionalblobOptionalcontentoptionally added to the entity
+OptionaldateOptionaldateOptionalisOptionalisOptionalisOptionalnoteeither noteId or revisionId to which this attachment belongs
+OptionalpositionOptionaltypeOptionalutcOptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryProtected_getProtected_setOptionalisDeleted: booleantrue if the note has string content (not binary)
+Mark the entity as (soft) deleted. It will be completely erased later.
+This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
+Optionalopts: {}Optionalopts: ContentOptsAttribute is an abstract concept which has two real uses - label (key - value pair) +and relation (representing named relationship between source and target note)
+Optionalrow: AttributeRowOptionalblobOptionaldateOptionaldateOptionalisOptionalisOptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryProtected_getProtected_setOptionalisInheritable: booleanOptionalisDeleted: booleanProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
+This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
+Optionalopts: {}Branch represents a relationship between a child note and its parent note. Trilium allows a note to have multiple +parents.
+Note that you should not rely on the branch's identity, since it can change easily with a note's move. +Always check noteId instead.
+OptionalblobOptionalbranchOptionaldateOptionaldateOptionalisOptionalisOptionalutcProtectedbeccaBranch is weak when its existence should not hinder deletion of its note. +As a result, note with only weak branches should be immediately deleted. +An example is shared or bookmarked clones - they are created automatically and exist for technical reasons, +not as user-intended actions. From user perspective, they don't count as real clones and for the purpose +of deletion should not act as a clone.
+root branch will have undefined parent, all other branches have to have a parent note
+StaticentityStatichashedStaticprimaryProtected_getProtected_setOptionalnotePosition: numberDelete a branch. If this is a last note's branch, delete the note as well.
+OptionaldeleteId: stringoptional delete identified
+OptionaltaskContext: TaskContexttrue if note has been deleted, false otherwise
+OptionalisDeleted: booleanProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
+This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
+Optionalopts: {}EtapiToken is an entity representing token used to authenticate against Trilium REST API from client applications. +Used by:
+The format user is presented with is "
Optionalrow: EtapiTokenRowOptionalblobOptionaldateOptionaldateOptionaletapiOptionalisOptionalisOptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryProtected_getProtected_setOptionalisDeleted: booleanProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
+This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
+Optionalopts: {}Trilium's main entity, which can represent text note, image, code note, file attachment etc.
+Optionalblobsize of the note content, attachment contents and revision contents in bytes
+size of the note content, attachment contents in bytes
+size of the content in bytes
+OptionaldateOptionaldateset during the deletion operation, before it is completed (removed from becca completely).
+OptionalisOptionalisnumber of note revisions for this note
+OptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryOptionaltype: null | stringOptionalname: null | stringProtected_getProtected_setAdds a new attribute to this note. The attribute is saved and returned. +See addLabel, addRelation for more specific methods.
+attribute type (label / relation)
+name of the attribute, not including the leading ~/#
+value of the attribute - text for labels, target note ID for relations; optional.
+Adds a new label to this note. The label attribute is saved and returned.
+name of the label, not including the leading #
+text value of the label; optional
+Adds a new relation to this note. The relation attribute is saved and +returned.
+name of the relation, not including the leading ~
+Some notes are eligible for conversion into an attachment of its parent, note must have these properties:
+Currently, works only for image notes.
+In the future, this functionality might get more generic and some of the requirements relaxed.
+null if note is not eligible for conversion
+(Soft) delete a note and all its descendants.
+optional delete identified
+OptionalisDeleted: booleanGives all possible note paths leading to this note. Paths containing search note are ignored (could form cycles)
+array of notePaths (each represented by array of noteIds constituting the particular note path)
+attribute type (label, relation, etc.)
+attribute name
+attribute of the given type and name. If there are more such attributes, first is returned. +Returns null if there's no such attribute belonging to this note.
+Optionalvalue: null | stringBeware that the method must not create a copy of the array, but actually returns its internal array +(for performance reasons)
+Optionaltype: string(optional) attribute type to filter
+Optionalname: string(optional) attribute name to filter
+all note's attributes, including inherited ones
+attribute type (label, relation, etc.)
+attribute name
+attribute value of given type and name or null if no such attribute exists.
+Returns a note path considered to be the "best"
+array of noteIds constituting the particular note path
+Returns a note path considered to be the "best"
+serialized note path (e.g. 'root/a1h315/js725h')
+Note content has quite special handling - it's not a separate entity, but a lazily loaded +part of Note entity with its own sync. Reasons behind this hybrid design has been:
+This is used for:
+returns only notes which are templated, does not include their subtrees +in effect returns notes which are influenced by note's non-inheritable attributes
+valid object or null if the content cannot be parsed as JSON
+Optionalname: stringlabel name to filter
+all note's labels (attributes with type label), including inherited ones
+label name
+label value if label exists, null otherwise
+label name to filter
+all note's label values, including inherited ones
+attribute belonging to this specific note (excludes inherited attributes)
+This method can be significantly faster than the getAttribute()
+Beware that the method must not create a copy of the array, but actually returns its internal array +(for performance reasons)
+(optional) attribute type to filter
+(optional) attribute name to filter
+(optional) attribute value to filter
+note's "owned" attributes - excluding inherited ones
+attribute type (label, relation, etc.)
+attribute name
+attribute value of given type and name or null if no such attribute exists.
+label name to filter
+all note's labels (attributes with type label), excluding inherited ones
+label name
+label value if label exists, null otherwise
+label name to filter
+all note's label values, excluding inherited ones
+relation name
+relation if it exists, null otherwise
+Optionalname: null | stringrelation name to filter
+all note's relations (attributes with type relation), excluding inherited ones
+relation name
+relation value if relation exists, null otherwise
+relation name
+relation if it exists, null otherwise
+Optionalname: stringrelation name to filter
+all note's relations (attributes with type relation), including inherited ones
+relation name
+relation value if relation exists, null otherwise
+JS script environment - either "frontend" or "backend"
+Returns strong (as opposed to weak) parent branches. See isWeak for details.
+includes the subtree root note as well
+label name
+Optionalvalue: stringlabel value
+true if label exists (including inherited)
+attribute name
+Optionalvalue: stringattribute value
+true if note has an attribute with given type and name (excluding inherited)
+label name
+Optionalvalue: stringlabel value
+true if label exists (excluding inherited)
+relation name
+Optionalvalue: stringrelation value
+true if relation exists (excluding inherited)
+relation name
+Optionalvalue: stringrelation value
+true if relation exists (including inherited)
+true if the note has string content (not binary)
+true if ancestorNoteId occurs in at least one of the note's paths
+boolean - true if there's no non-hidden path, note is not cloned to the visible tree
+true if this note is HTML
+true if this note is an image
+true if this note is JavaScript (code or attachment)
+true if this note is of application/json content type
+label name
+true if label exists (including inherited) and does not have "false" value.
+true if this note is the root of the note tree. Root note has "root" noteId
+Mark the entity as (soft) deleted. It will be completely erased later.
+This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputRemoves given attribute name-value pair if it exists.
+attribute type (label, relation, etc.)
+attribute name
+Optionalvalue: stringattribute value (optional)
+Remove label name-value pair, if it exists.
+label name
+Optionalvalue: stringlabel value
+Remove the relation name-value pair, if it exists.
+relation name
+Optionalvalue: stringrelation value (noteId)
+Saves entity - executes SQL, but doesn't commit the transaction on its own
+Optionalopts: {}choose by which property we detect if to update an existing attachment. +Supported values are either 'attachmentId' (default) or 'title'
+Update's given attribute's value or creates it if it doesn't exist
+attribute type (label, relation, etc.)
+attribute name
+Optionalvalue: stringattribute value (optional)
+Update's given label's value or creates it if it doesn't exist
+label name
+Optionalvalue: stringlabel value
+Update's given relation's value or creates it if it doesn't exist
+relation name
+Optionalvalue: stringrelation value (noteId)
+Based on enabled, the attribute is either set or removed.
+attribute type ('relation', 'label' etc.)
+toggle On or Off
+attribute name
+Optionalvalue: stringattribute value (optional)
+Based on enabled, label is either set or removed.
+toggle On or Off
+label name
+Optionalvalue: stringlabel value (optional)
+Based on enabled, relation is either set or removed.
+toggle On or Off
+relation name
+Optionalvalue: stringrelation value (noteId)
+Option represents a name-value pair, either directly configurable by the user or some system property.
+OptionalblobOptionaldateOptionaldateOptionalisOptionalisOptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryProtected_getProtected_setOptionalisDeleted: booleanProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
+This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
+Optionalopts: {}Revision represents a snapshot of note's title and content at some point in the past. +It's used for seamless note versioning.
+OptionalblobOptionalcontentOptionalcontentOptionaldateOptionaldateOptionaldateOptionalisOptionalisOptionalrevisionOptionalutcOptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryProtected_getProtected_setRevisions are not soft-deletable, they are immediately hard-deleted (erased).
+OptionalisDeleted: booleanvalid object or null if the content cannot be parsed as JSON
+true if the note has string content (not binary)
+Mark the entity as (soft) deleted. It will be completely erased later.
+This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
+Optionalopts: {}Optionalmessage: stringOptionalcode: stringOptionalconfig: InternalAxiosRequestConfig<any>Optionalrequest: anyOptionalresponse: AxiosResponse<T, any>OptionalcauseOptionalcodeOptionalconfigOptionalrequestOptionalresponseOptionalstackOptionalstatusStatic ReadonlyECONNABORTEDStatic ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyERR_Static ReadonlyETIMEDOUTStatic OptionalprepareOptional override for formatting stack traces
+StaticstackStaticcaptureCreate .stack property on a target object
+OptionalconstructorOpt: FunctionStaticfromOptionalcode: stringOptionalconfig: InternalAxiosRequestConfig<D>Optionalrequest: anyOptionalresponse: AxiosResponse<T, D>OptionalcustomProps: objectIntegrates EventEmitter with AsyncResource for EventEmitters that
+require manual async tracking. Specifically, all events emitted by instances
+of events.EventEmitterAsyncResource will run within its async context.
import { EventEmitterAsyncResource, EventEmitter } from 'node:events';
import { notStrictEqual, strictEqual } from 'node:assert';
import { executionAsyncId, triggerAsyncId } from 'node:async_hooks';
// Async tracking tooling will identify this as 'Q'.
const ee1 = new EventEmitterAsyncResource({ name: 'Q' });
// 'foo' listeners will run in the EventEmitters async context.
ee1.on('foo', () => {
strictEqual(executionAsyncId(), ee1.asyncId);
strictEqual(triggerAsyncId(), ee1.triggerAsyncId);
});
const ee2 = new EventEmitter();
// 'foo' listeners on ordinary EventEmitters that do not track async
// context, however, run in the same async context as the emit().
ee2.on('foo', () => {
notStrictEqual(executionAsyncId(), ee2.asyncId);
notStrictEqual(triggerAsyncId(), ee2.triggerAsyncId);
});
Promise.resolve().then(() => {
ee1.emit('foo');
ee2.emit('foo');
});
+The EventEmitterAsyncResource class has the same methods and takes the
+same options as EventEmitter and AsyncResource themselves.
Optionaloptions: EventEmitterAsyncResourceOptionsOnly optional in child class.
+ReadonlyasyncThe unique asyncId assigned to the resource.
ReadonlyasyncThe returned AsyncResource object has an additional eventEmitter property
+that provides a reference to this EventEmitterAsyncResource.
ReadonlytriggerThe same triggerAsyncId that is passed to the AsyncResource constructor.
+StaticcaptureValue: boolean
+Change the default captureRejections option on all new EventEmitter objects.
Static ReadonlycaptureValue: Symbol.for('nodejs.rejection')
See how to write a custom rejection handler.
StaticdefaultBy default, a maximum of 10 listeners can be registered for any single
+event. This limit can be changed for individual EventEmitter instances
+using the emitter.setMaxListeners(n) method. To change the default
+for allEventEmitter instances, the events.defaultMaxListeners property
+can be used. If this value is not a positive number, a RangeError is thrown.
Take caution when setting the events.defaultMaxListeners because the
+change affects all EventEmitter instances, including those created before
+the change is made. However, calling emitter.setMaxListeners(n) still has
+precedence over events.defaultMaxListeners.
This is not a hard limit. The EventEmitter instance will allow
+more listeners to be added but will output a trace warning to stderr indicating
+that a "possible EventEmitter memory leak" has been detected. For any single
+EventEmitter, the emitter.getMaxListeners() and emitter.setMaxListeners() methods can be used to
+temporarily avoid this warning:
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
// do stuff
emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});
+The --trace-warnings command-line flag can be used to display the
+stack trace for such warnings.
The emitted warning can be inspected with process.on('warning') and will
+have the additional emitter, type, and count properties, referring to
+the event emitter instance, the event's name and the number of attached
+listeners, respectively.
+Its name property is set to 'MaxListenersExceededWarning'.
Static ReadonlyerrorThis symbol shall be used to install a listener for only monitoring 'error' events. Listeners installed using this symbol are called before the regular 'error' listeners are called.
Installing a listener using this symbol does not change the behavior once an 'error' event is emitted. Therefore, the process will still crash if no
+regular 'error' listener is installed.
Optional[captureSynchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments
+to each.
Returns true if the event had listeners, false otherwise.
import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();
// First listener
myEmitter.on('event', function firstListener() {
console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
const parameters = args.join(', ');
console.log(`event with parameters ${parameters} in third listener`);
});
console.log(myEmitter.listeners('event'));
myEmitter.emit('event', 1, 2, 3, 4, 5);
// Prints:
// [
// [Function: firstListener],
// [Function: secondListener],
// [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
+Call all destroy hooks. This should only ever be called once. An error will
+be thrown if it is called more than once. This must be manually called. If
+the resource is left to be collected by the GC then the destroy hooks will
+never be called.
Returns an array listing the events for which the emitter has registered
+listeners. The values in the array are strings or Symbols.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
+Returns the current max listener value for the EventEmitter which is either
+set by emitter.setMaxListeners(n) or defaults to EventEmitter.defaultMaxListeners.
Returns the number of listeners listening for the event named eventName.
+If listener is provided, it will return how many times the listener is found
+in the list of the listeners of the event.
The name of the event being listened for
+Optionallistener: FunctionThe event handler function
+Returns a copy of the array of listeners for the event named eventName.
server.on('connection', (stream) => {
console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
+Adds the listener function to the end of the listeners array for the event
+named eventName. No checks are made to see if the listener has already
+been added. Multiple calls passing the same combination of eventName and
+listener will result in the listener being added, and called, multiple times.
server.on('connection', (stream) => {
console.log('someone connected!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the
+event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
+The name of the event.
+The callback function
+Adds a one-time listener function for the event named eventName. The
+next time eventName is triggered, this listener is removed and then invoked.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the
+event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
+The name of the event.
+The callback function
+Adds the listener function to the beginning of the listeners array for the
+event named eventName. No checks are made to see if the listener has
+already been added. Multiple calls passing the same combination of eventName
+and listener will result in the listener being added, and called, multiple times.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
The name of the event.
+The callback function
+Adds a one-timelistener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this
+listener is removed, and then invoked.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
The name of the event.
+The callback function
+Returns a copy of the array of listeners for the event named eventName,
+including any wrappers (such as those created by .once()).
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
+Removes all listeners, or those of the specified eventName.
It is bad practice to remove listeners added elsewhere in the code,
+particularly when the EventEmitter instance was created by some other
+component or module (e.g. sockets or file streams).
Returns a reference to the EventEmitter, so that calls can be chained.
OptionaleventName: string | symbolRemoves the specified listener from the listener array for the event named eventName.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
+removeListener() will remove, at most, one instance of a listener from the
+listener array. If any single listener has been added multiple times to the
+listener array for the specified eventName, then removeListener() must be
+called multiple times to remove each instance.
Once an event is emitted, all listeners attached to it at the
+time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution
+will not remove them fromemit() in progress. Subsequent events behave as expected.
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
+Because listeners are managed using an internal array, calling this will
+change the position indices of any listener registered after the listener
+being removed. This will not impact the order in which listeners are called,
+but it means that any copies of the listener array as returned by
+the emitter.listeners() method will need to be recreated.
When a single function has been added as a handler multiple times for a single
+event (as in the example below), removeListener() will remove the most
+recently added instance. In the example the once('ping') listener is removed:
import { EventEmitter } from 'node:events';
const ee = new EventEmitter();
function pong() {
console.log('pong');
}
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
ee.emit('ping');
ee.emit('ping');
+Returns a reference to the EventEmitter, so that calls can be chained.
By default EventEmitters will print a warning if more than 10 listeners are
+added for a particular event. This is a useful default that helps finding
+memory leaks. The emitter.setMaxListeners() method allows the limit to be
+modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.
Returns a reference to the EventEmitter, so that calls can be chained.
StaticaddExperimentalListens once to the abort event on the provided signal.
Listening to the abort event on abort signals is unsafe and may
+lead to resource leaks since another third party with the signal can
+call e.stopImmediatePropagation(). Unfortunately Node.js cannot change
+this since it would violate the web standard. Additionally, the original
+API makes it easy to forget to remove listeners.
This API allows safely using AbortSignals in Node.js APIs by solving these
+two issues by listening to the event such that stopImmediatePropagation does
+not prevent the listener from running.
Returns a disposable so that it may be unsubscribed from more easily.
+import { addAbortListener } from 'node:events';
function example(signal) {
let disposable;
try {
signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
disposable = addAbortListener(signal, (e) => {
// Do something when signal is aborted.
});
} finally {
disposable?.[Symbol.dispose]();
}
}
+Disposable that removes the abort listener.
StaticgetReturns a copy of the array of listeners for the event named eventName.
For EventEmitters this behaves exactly the same as calling .listeners on
+the emitter.
For EventTargets this is the only way to get the event listeners for the
+event target. This is useful for debugging and diagnostic purposes.
import { getEventListeners, EventEmitter } from 'node:events';
{
const ee = new EventEmitter();
const listener = () => console.log('Events are fun');
ee.on('foo', listener);
console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
const et = new EventTarget();
const listener = () => console.log('Events are fun');
et.addEventListener('foo', listener);
console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}
+StaticgetReturns the currently set max amount of listeners.
+For EventEmitters this behaves exactly the same as calling .getMaxListeners on
+the emitter.
For EventTargets this is the only way to get the max event listeners for the
+event target. If the number of event handlers on a single EventTarget exceeds
+the max set, the EventTarget will print a warning.
import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';
{
const ee = new EventEmitter();
console.log(getMaxListeners(ee)); // 10
setMaxListeners(11, ee);
console.log(getMaxListeners(ee)); // 11
}
{
const et = new EventTarget();
console.log(getMaxListeners(et)); // 10
setMaxListeners(11, et);
console.log(getMaxListeners(et)); // 11
}
+StaticlistenerA class method that returns the number of listeners for the given eventName registered on the given emitter.
import { EventEmitter, listenerCount } from 'node:events';
const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2
+The emitter to query
+The event name
+Staticonimport { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo')) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
+Returns an AsyncIterator that iterates eventName events. It will throw
+if the EventEmitter emits 'error'. It removes all listeners when
+exiting the loop. The value returned by each iteration is an array
+composed of the emitted event arguments.
An AbortSignal can be used to cancel waiting on events:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ac = new AbortController();
(async () => {
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo', { signal: ac.signal })) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
})();
process.nextTick(() => ac.abort());
+Use the close option to specify an array of event names that will end the iteration:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
ee.emit('close');
});
for await (const event of on(ee, 'foo', { close: ['close'] })) {
console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'
+Optionaloptions: StaticEventEmitterIteratorOptionsAn AsyncIterator that iterates eventName events emitted by the emitter
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo')) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
+Returns an AsyncIterator that iterates eventName events. It will throw
+if the EventEmitter emits 'error'. It removes all listeners when
+exiting the loop. The value returned by each iteration is an array
+composed of the emitted event arguments.
An AbortSignal can be used to cancel waiting on events:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ac = new AbortController();
(async () => {
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo', { signal: ac.signal })) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
})();
process.nextTick(() => ac.abort());
+Use the close option to specify an array of event names that will end the iteration:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
ee.emit('close');
});
for await (const event of on(ee, 'foo', { close: ['close'] })) {
console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'
+Optionaloptions: StaticEventEmitterIteratorOptionsAn AsyncIterator that iterates eventName events emitted by the emitter
StaticonceCreates a Promise that is fulfilled when the EventEmitter emits the given
+event or that is rejected if the EventEmitter emits 'error' while waiting.
+The Promise will resolve with an array of all the arguments emitted to the
+given event.
This method is intentionally generic and works with the web platform EventTarget interface, which has no special'error' event
+semantics and does not listen to the 'error' event.
import { once, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
process.nextTick(() => {
ee.emit('myevent', 42);
});
const [value] = await once(ee, 'myevent');
console.log(value);
const err = new Error('kaboom');
process.nextTick(() => {
ee.emit('error', err);
});
try {
await once(ee, 'myevent');
} catch (err) {
console.error('error happened', err);
}
+The special handling of the 'error' event is only used when events.once() is used to wait for another event. If events.once() is used to wait for the
+'error' event itself, then it is treated as any other kind of event without
+special handling:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
once(ee, 'error')
.then(([err]) => console.log('ok', err.message))
.catch((err) => console.error('error', err.message));
ee.emit('error', new Error('boom'));
// Prints: ok boom
+An AbortSignal can be used to cancel waiting for the event:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
const ac = new AbortController();
async function foo(emitter, event, signal) {
try {
await once(emitter, event, { signal });
console.log('event emitted!');
} catch (error) {
if (error.name === 'AbortError') {
console.error('Waiting for the event was canceled!');
} else {
console.error('There was an error', error.message);
}
}
}
foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
+Optionaloptions: StaticEventEmitterOptionsCreates a Promise that is fulfilled when the EventEmitter emits the given
+event or that is rejected if the EventEmitter emits 'error' while waiting.
+The Promise will resolve with an array of all the arguments emitted to the
+given event.
This method is intentionally generic and works with the web platform EventTarget interface, which has no special'error' event
+semantics and does not listen to the 'error' event.
import { once, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
process.nextTick(() => {
ee.emit('myevent', 42);
});
const [value] = await once(ee, 'myevent');
console.log(value);
const err = new Error('kaboom');
process.nextTick(() => {
ee.emit('error', err);
});
try {
await once(ee, 'myevent');
} catch (err) {
console.error('error happened', err);
}
+The special handling of the 'error' event is only used when events.once() is used to wait for another event. If events.once() is used to wait for the
+'error' event itself, then it is treated as any other kind of event without
+special handling:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
once(ee, 'error')
.then(([err]) => console.log('ok', err.message))
.catch((err) => console.error('error', err.message));
ee.emit('error', new Error('boom'));
// Prints: ok boom
+An AbortSignal can be used to cancel waiting for the event:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
const ac = new AbortController();
async function foo(emitter, event, signal) {
try {
await once(emitter, event, { signal });
console.log('event emitted!');
} catch (error) {
if (error.name === 'AbortError') {
console.error('Waiting for the event was canceled!');
} else {
console.error('There was an error', error.message);
}
}
}
foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
+Optionaloptions: StaticEventEmitterOptionsStaticsetimport { setMaxListeners, EventEmitter } from 'node:events';
const target = new EventTarget();
const emitter = new EventEmitter();
setMaxListeners(5, target, emitter);
+Optionaln: numberA non-negative number. The maximum number of listeners per EventTarget event.
Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, n is set as the default max for all newly created {EventTarget} and {EventEmitter}
+objects.
The EventEmitter class is defined and exposed by the node:events module:
import { EventEmitter } from 'node:events';
+All EventEmitters emit the event 'newListener' when new listeners are
+added and 'removeListener' when existing listeners are removed.
It supports the following option:
+Optionaloptions: EventEmitterOptionsStaticcaptureValue: boolean
+Change the default captureRejections option on all new EventEmitter objects.
Static ReadonlycaptureValue: Symbol.for('nodejs.rejection')
See how to write a custom rejection handler.
StaticdefaultBy default, a maximum of 10 listeners can be registered for any single
+event. This limit can be changed for individual EventEmitter instances
+using the emitter.setMaxListeners(n) method. To change the default
+for allEventEmitter instances, the events.defaultMaxListeners property
+can be used. If this value is not a positive number, a RangeError is thrown.
Take caution when setting the events.defaultMaxListeners because the
+change affects all EventEmitter instances, including those created before
+the change is made. However, calling emitter.setMaxListeners(n) still has
+precedence over events.defaultMaxListeners.
This is not a hard limit. The EventEmitter instance will allow
+more listeners to be added but will output a trace warning to stderr indicating
+that a "possible EventEmitter memory leak" has been detected. For any single
+EventEmitter, the emitter.getMaxListeners() and emitter.setMaxListeners() methods can be used to
+temporarily avoid this warning:
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
// do stuff
emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});
+The --trace-warnings command-line flag can be used to display the
+stack trace for such warnings.
The emitted warning can be inspected with process.on('warning') and will
+have the additional emitter, type, and count properties, referring to
+the event emitter instance, the event's name and the number of attached
+listeners, respectively.
+Its name property is set to 'MaxListenersExceededWarning'.
Static ReadonlyerrorThis symbol shall be used to install a listener for only monitoring 'error' events. Listeners installed using this symbol are called before the regular 'error' listeners are called.
Installing a listener using this symbol does not change the behavior once an 'error' event is emitted. Therefore, the process will still crash if no
+regular 'error' listener is installed.
Optional[captureSynchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments
+to each.
Returns true if the event had listeners, false otherwise.
import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();
// First listener
myEmitter.on('event', function firstListener() {
console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
const parameters = args.join(', ');
console.log(`event with parameters ${parameters} in third listener`);
});
console.log(myEmitter.listeners('event'));
myEmitter.emit('event', 1, 2, 3, 4, 5);
// Prints:
// [
// [Function: firstListener],
// [Function: secondListener],
// [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
+Returns an array listing the events for which the emitter has registered
+listeners. The values in the array are strings or Symbols.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
+Returns the current max listener value for the EventEmitter which is either
+set by emitter.setMaxListeners(n) or defaults to EventEmitter.defaultMaxListeners.
Returns the number of listeners listening for the event named eventName.
+If listener is provided, it will return how many times the listener is found
+in the list of the listeners of the event.
Adds the listener function to the end of the listeners array for the event
+named eventName. No checks are made to see if the listener has already
+been added. Multiple calls passing the same combination of eventName and
+listener will result in the listener being added, and called, multiple times.
server.on('connection', (stream) => {
console.log('someone connected!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the
+event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
+Adds a one-time listener function for the event named eventName. The
+next time eventName is triggered, this listener is removed and then invoked.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the
+event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
+Adds the listener function to the beginning of the listeners array for the
+event named eventName. No checks are made to see if the listener has
+already been added. Multiple calls passing the same combination of eventName
+and listener will result in the listener being added, and called, multiple times.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
Adds a one-timelistener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this
+listener is removed, and then invoked.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
Returns a copy of the array of listeners for the event named eventName,
+including any wrappers (such as those created by .once()).
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
+Removes all listeners, or those of the specified eventName.
It is bad practice to remove listeners added elsewhere in the code,
+particularly when the EventEmitter instance was created by some other
+component or module (e.g. sockets or file streams).
Returns a reference to the EventEmitter, so that calls can be chained.
Removes the specified listener from the listener array for the event named eventName.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
+removeListener() will remove, at most, one instance of a listener from the
+listener array. If any single listener has been added multiple times to the
+listener array for the specified eventName, then removeListener() must be
+called multiple times to remove each instance.
Once an event is emitted, all listeners attached to it at the
+time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution
+will not remove them fromemit() in progress. Subsequent events behave as expected.
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
+Because listeners are managed using an internal array, calling this will
+change the position indices of any listener registered after the listener
+being removed. This will not impact the order in which listeners are called,
+but it means that any copies of the listener array as returned by
+the emitter.listeners() method will need to be recreated.
When a single function has been added as a handler multiple times for a single
+event (as in the example below), removeListener() will remove the most
+recently added instance. In the example the once('ping') listener is removed:
import { EventEmitter } from 'node:events';
const ee = new EventEmitter();
function pong() {
console.log('pong');
}
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
ee.emit('ping');
ee.emit('ping');
+Returns a reference to the EventEmitter, so that calls can be chained.
By default EventEmitters will print a warning if more than 10 listeners are
+added for a particular event. This is a useful default that helps finding
+memory leaks. The emitter.setMaxListeners() method allows the limit to be
+modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.
Returns a reference to the EventEmitter, so that calls can be chained.
StaticaddExperimentalListens once to the abort event on the provided signal.
Listening to the abort event on abort signals is unsafe and may
+lead to resource leaks since another third party with the signal can
+call e.stopImmediatePropagation(). Unfortunately Node.js cannot change
+this since it would violate the web standard. Additionally, the original
+API makes it easy to forget to remove listeners.
This API allows safely using AbortSignals in Node.js APIs by solving these
+two issues by listening to the event such that stopImmediatePropagation does
+not prevent the listener from running.
Returns a disposable so that it may be unsubscribed from more easily.
+import { addAbortListener } from 'node:events';
function example(signal) {
let disposable;
try {
signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
disposable = addAbortListener(signal, (e) => {
// Do something when signal is aborted.
});
} finally {
disposable?.[Symbol.dispose]();
}
}
+Disposable that removes the abort listener.
StaticgetReturns a copy of the array of listeners for the event named eventName.
For EventEmitters this behaves exactly the same as calling .listeners on
+the emitter.
For EventTargets this is the only way to get the event listeners for the
+event target. This is useful for debugging and diagnostic purposes.
import { getEventListeners, EventEmitter } from 'node:events';
{
const ee = new EventEmitter();
const listener = () => console.log('Events are fun');
ee.on('foo', listener);
console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
const et = new EventTarget();
const listener = () => console.log('Events are fun');
et.addEventListener('foo', listener);
console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}
+StaticgetReturns the currently set max amount of listeners.
+For EventEmitters this behaves exactly the same as calling .getMaxListeners on
+the emitter.
For EventTargets this is the only way to get the max event listeners for the
+event target. If the number of event handlers on a single EventTarget exceeds
+the max set, the EventTarget will print a warning.
import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';
{
const ee = new EventEmitter();
console.log(getMaxListeners(ee)); // 10
setMaxListeners(11, ee);
console.log(getMaxListeners(ee)); // 11
}
{
const et = new EventTarget();
console.log(getMaxListeners(et)); // 10
setMaxListeners(11, et);
console.log(getMaxListeners(et)); // 11
}
+StaticlistenerA class method that returns the number of listeners for the given eventName registered on the given emitter.
import { EventEmitter, listenerCount } from 'node:events';
const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2
+The emitter to query
+The event name
+Staticonimport { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo')) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
+Returns an AsyncIterator that iterates eventName events. It will throw
+if the EventEmitter emits 'error'. It removes all listeners when
+exiting the loop. The value returned by each iteration is an array
+composed of the emitted event arguments.
An AbortSignal can be used to cancel waiting on events:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ac = new AbortController();
(async () => {
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo', { signal: ac.signal })) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
})();
process.nextTick(() => ac.abort());
+Use the close option to specify an array of event names that will end the iteration:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
ee.emit('close');
});
for await (const event of on(ee, 'foo', { close: ['close'] })) {
console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'
+Optionaloptions: StaticEventEmitterIteratorOptionsAn AsyncIterator that iterates eventName events emitted by the emitter
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo')) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
+Returns an AsyncIterator that iterates eventName events. It will throw
+if the EventEmitter emits 'error'. It removes all listeners when
+exiting the loop. The value returned by each iteration is an array
+composed of the emitted event arguments.
An AbortSignal can be used to cancel waiting on events:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ac = new AbortController();
(async () => {
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo', { signal: ac.signal })) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
})();
process.nextTick(() => ac.abort());
+Use the close option to specify an array of event names that will end the iteration:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
ee.emit('close');
});
for await (const event of on(ee, 'foo', { close: ['close'] })) {
console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'
+Optionaloptions: StaticEventEmitterIteratorOptionsAn AsyncIterator that iterates eventName events emitted by the emitter
StaticonceCreates a Promise that is fulfilled when the EventEmitter emits the given
+event or that is rejected if the EventEmitter emits 'error' while waiting.
+The Promise will resolve with an array of all the arguments emitted to the
+given event.
This method is intentionally generic and works with the web platform EventTarget interface, which has no special'error' event
+semantics and does not listen to the 'error' event.
import { once, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
process.nextTick(() => {
ee.emit('myevent', 42);
});
const [value] = await once(ee, 'myevent');
console.log(value);
const err = new Error('kaboom');
process.nextTick(() => {
ee.emit('error', err);
});
try {
await once(ee, 'myevent');
} catch (err) {
console.error('error happened', err);
}
+The special handling of the 'error' event is only used when events.once() is used to wait for another event. If events.once() is used to wait for the
+'error' event itself, then it is treated as any other kind of event without
+special handling:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
once(ee, 'error')
.then(([err]) => console.log('ok', err.message))
.catch((err) => console.error('error', err.message));
ee.emit('error', new Error('boom'));
// Prints: ok boom
+An AbortSignal can be used to cancel waiting for the event:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
const ac = new AbortController();
async function foo(emitter, event, signal) {
try {
await once(emitter, event, { signal });
console.log('event emitted!');
} catch (error) {
if (error.name === 'AbortError') {
console.error('Waiting for the event was canceled!');
} else {
console.error('There was an error', error.message);
}
}
}
foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
+Optionaloptions: StaticEventEmitterOptionsCreates a Promise that is fulfilled when the EventEmitter emits the given
+event or that is rejected if the EventEmitter emits 'error' while waiting.
+The Promise will resolve with an array of all the arguments emitted to the
+given event.
This method is intentionally generic and works with the web platform EventTarget interface, which has no special'error' event
+semantics and does not listen to the 'error' event.
import { once, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
process.nextTick(() => {
ee.emit('myevent', 42);
});
const [value] = await once(ee, 'myevent');
console.log(value);
const err = new Error('kaboom');
process.nextTick(() => {
ee.emit('error', err);
});
try {
await once(ee, 'myevent');
} catch (err) {
console.error('error happened', err);
}
+The special handling of the 'error' event is only used when events.once() is used to wait for another event. If events.once() is used to wait for the
+'error' event itself, then it is treated as any other kind of event without
+special handling:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
once(ee, 'error')
.then(([err]) => console.log('ok', err.message))
.catch((err) => console.error('error', err.message));
ee.emit('error', new Error('boom'));
// Prints: ok boom
+An AbortSignal can be used to cancel waiting for the event:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
const ac = new AbortController();
async function foo(emitter, event, signal) {
try {
await once(emitter, event, { signal });
console.log('event emitted!');
} catch (error) {
if (error.name === 'AbortError') {
console.error('Waiting for the event was canceled!');
} else {
console.error('There was an error', error.message);
}
}
}
foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
+Optionaloptions: StaticEventEmitterOptionsStaticsetimport { setMaxListeners, EventEmitter } from 'node:events';
const target = new EventTarget();
const emitter = new EventEmitter();
setMaxListeners(5, target, emitter);
+Optionaln: numberA non-negative number. The maximum number of listeners per EventTarget event.
Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, n is set as the default max for all newly created {EventTarget} and {EventEmitter}
+objects.
Optionalresult: string | Record<string, undefined | string>StaticgetBecca is a backend cache of all notes, branches, and attributes. +There's a similar frontend cache Froca, and share cache Shaca.
+Points from attribute type-name to list of attributes
+Should be called when the set of all non-skeleton notes changes (added/removed)
+Optionaloptions: BuilderOptionsThe EventEmitter class is defined and exposed by the node:events module:
import { EventEmitter } from 'node:events';
+All EventEmitters emit the event 'newListener' when new listeners are
+added and 'removeListener' when existing listeners are removed.
It supports the following option:
+Optionaloptions: ParserOptionsStaticcaptureValue: boolean
+Change the default captureRejections option on all new EventEmitter objects.
Static ReadonlycaptureValue: Symbol.for('nodejs.rejection')
See how to write a custom rejection handler.
StaticdefaultBy default, a maximum of 10 listeners can be registered for any single
+event. This limit can be changed for individual EventEmitter instances
+using the emitter.setMaxListeners(n) method. To change the default
+for allEventEmitter instances, the events.defaultMaxListeners property
+can be used. If this value is not a positive number, a RangeError is thrown.
Take caution when setting the events.defaultMaxListeners because the
+change affects all EventEmitter instances, including those created before
+the change is made. However, calling emitter.setMaxListeners(n) still has
+precedence over events.defaultMaxListeners.
This is not a hard limit. The EventEmitter instance will allow
+more listeners to be added but will output a trace warning to stderr indicating
+that a "possible EventEmitter memory leak" has been detected. For any single
+EventEmitter, the emitter.getMaxListeners() and emitter.setMaxListeners() methods can be used to
+temporarily avoid this warning:
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
// do stuff
emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});
+The --trace-warnings command-line flag can be used to display the
+stack trace for such warnings.
The emitted warning can be inspected with process.on('warning') and will
+have the additional emitter, type, and count properties, referring to
+the event emitter instance, the event's name and the number of attached
+listeners, respectively.
+Its name property is set to 'MaxListenersExceededWarning'.
Static ReadonlyerrorThis symbol shall be used to install a listener for only monitoring 'error' events. Listeners installed using this symbol are called before the regular 'error' listeners are called.
Installing a listener using this symbol does not change the behavior once an 'error' event is emitted. Therefore, the process will still crash if no
+regular 'error' listener is installed.
Optional[captureSynchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments
+to each.
Returns true if the event had listeners, false otherwise.
import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();
// First listener
myEmitter.on('event', function firstListener() {
console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
const parameters = args.join(', ');
console.log(`event with parameters ${parameters} in third listener`);
});
console.log(myEmitter.listeners('event'));
myEmitter.emit('event', 1, 2, 3, 4, 5);
// Prints:
// [
// [Function: firstListener],
// [Function: secondListener],
// [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
+Returns an array listing the events for which the emitter has registered
+listeners. The values in the array are strings or Symbols.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
+Returns the current max listener value for the EventEmitter which is either
+set by emitter.setMaxListeners(n) or defaults to EventEmitter.defaultMaxListeners.
Returns the number of listeners listening for the event named eventName.
+If listener is provided, it will return how many times the listener is found
+in the list of the listeners of the event.
The name of the event being listened for
+Optionallistener: FunctionThe event handler function
+Returns a copy of the array of listeners for the event named eventName.
server.on('connection', (stream) => {
console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
+Adds the listener function to the end of the listeners array for the event
+named eventName. No checks are made to see if the listener has already
+been added. Multiple calls passing the same combination of eventName and
+listener will result in the listener being added, and called, multiple times.
server.on('connection', (stream) => {
console.log('someone connected!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the
+event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
+The name of the event.
+The callback function
+Adds a one-time listener function for the event named eventName. The
+next time eventName is triggered, this listener is removed and then invoked.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the
+event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
+The name of the event.
+The callback function
+Optionalcb: (error: null | Error, result: any) => voidAdds the listener function to the beginning of the listeners array for the
+event named eventName. No checks are made to see if the listener has
+already been added. Multiple calls passing the same combination of eventName
+and listener will result in the listener being added, and called, multiple times.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
The name of the event.
+The callback function
+Adds a one-timelistener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this
+listener is removed, and then invoked.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
The name of the event.
+The callback function
+Returns a copy of the array of listeners for the event named eventName,
+including any wrappers (such as those created by .once()).
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
+Removes all listeners, or those of the specified eventName.
It is bad practice to remove listeners added elsewhere in the code,
+particularly when the EventEmitter instance was created by some other
+component or module (e.g. sockets or file streams).
Returns a reference to the EventEmitter, so that calls can be chained.
OptionaleventName: string | symbolRemoves the specified listener from the listener array for the event named eventName.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
+removeListener() will remove, at most, one instance of a listener from the
+listener array. If any single listener has been added multiple times to the
+listener array for the specified eventName, then removeListener() must be
+called multiple times to remove each instance.
Once an event is emitted, all listeners attached to it at the
+time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution
+will not remove them fromemit() in progress. Subsequent events behave as expected.
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
+Because listeners are managed using an internal array, calling this will
+change the position indices of any listener registered after the listener
+being removed. This will not impact the order in which listeners are called,
+but it means that any copies of the listener array as returned by
+the emitter.listeners() method will need to be recreated.
When a single function has been added as a handler multiple times for a single
+event (as in the example below), removeListener() will remove the most
+recently added instance. In the example the once('ping') listener is removed:
import { EventEmitter } from 'node:events';
const ee = new EventEmitter();
function pong() {
console.log('pong');
}
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
ee.emit('ping');
ee.emit('ping');
+Returns a reference to the EventEmitter, so that calls can be chained.
By default EventEmitters will print a warning if more than 10 listeners are
+added for a particular event. This is a useful default that helps finding
+memory leaks. The emitter.setMaxListeners() method allows the limit to be
+modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.
Returns a reference to the EventEmitter, so that calls can be chained.
StaticaddExperimentalListens once to the abort event on the provided signal.
Listening to the abort event on abort signals is unsafe and may
+lead to resource leaks since another third party with the signal can
+call e.stopImmediatePropagation(). Unfortunately Node.js cannot change
+this since it would violate the web standard. Additionally, the original
+API makes it easy to forget to remove listeners.
This API allows safely using AbortSignals in Node.js APIs by solving these
+two issues by listening to the event such that stopImmediatePropagation does
+not prevent the listener from running.
Returns a disposable so that it may be unsubscribed from more easily.
+import { addAbortListener } from 'node:events';
function example(signal) {
let disposable;
try {
signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
disposable = addAbortListener(signal, (e) => {
// Do something when signal is aborted.
});
} finally {
disposable?.[Symbol.dispose]();
}
}
+Disposable that removes the abort listener.
StaticgetReturns a copy of the array of listeners for the event named eventName.
For EventEmitters this behaves exactly the same as calling .listeners on
+the emitter.
For EventTargets this is the only way to get the event listeners for the
+event target. This is useful for debugging and diagnostic purposes.
import { getEventListeners, EventEmitter } from 'node:events';
{
const ee = new EventEmitter();
const listener = () => console.log('Events are fun');
ee.on('foo', listener);
console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
const et = new EventTarget();
const listener = () => console.log('Events are fun');
et.addEventListener('foo', listener);
console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}
+StaticgetReturns the currently set max amount of listeners.
+For EventEmitters this behaves exactly the same as calling .getMaxListeners on
+the emitter.
For EventTargets this is the only way to get the max event listeners for the
+event target. If the number of event handlers on a single EventTarget exceeds
+the max set, the EventTarget will print a warning.
import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';
{
const ee = new EventEmitter();
console.log(getMaxListeners(ee)); // 10
setMaxListeners(11, ee);
console.log(getMaxListeners(ee)); // 11
}
{
const et = new EventTarget();
console.log(getMaxListeners(et)); // 10
setMaxListeners(11, et);
console.log(getMaxListeners(et)); // 11
}
+StaticlistenerA class method that returns the number of listeners for the given eventName registered on the given emitter.
import { EventEmitter, listenerCount } from 'node:events';
const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2
+The emitter to query
+The event name
+Staticonimport { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo')) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
+Returns an AsyncIterator that iterates eventName events. It will throw
+if the EventEmitter emits 'error'. It removes all listeners when
+exiting the loop. The value returned by each iteration is an array
+composed of the emitted event arguments.
An AbortSignal can be used to cancel waiting on events:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ac = new AbortController();
(async () => {
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo', { signal: ac.signal })) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
})();
process.nextTick(() => ac.abort());
+Use the close option to specify an array of event names that will end the iteration:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
ee.emit('close');
});
for await (const event of on(ee, 'foo', { close: ['close'] })) {
console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'
+Optionaloptions: StaticEventEmitterIteratorOptionsAn AsyncIterator that iterates eventName events emitted by the emitter
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo')) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
+Returns an AsyncIterator that iterates eventName events. It will throw
+if the EventEmitter emits 'error'. It removes all listeners when
+exiting the loop. The value returned by each iteration is an array
+composed of the emitted event arguments.
An AbortSignal can be used to cancel waiting on events:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ac = new AbortController();
(async () => {
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo', { signal: ac.signal })) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
})();
process.nextTick(() => ac.abort());
+Use the close option to specify an array of event names that will end the iteration:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
ee.emit('close');
});
for await (const event of on(ee, 'foo', { close: ['close'] })) {
console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'
+Optionaloptions: StaticEventEmitterIteratorOptionsAn AsyncIterator that iterates eventName events emitted by the emitter
StaticonceCreates a Promise that is fulfilled when the EventEmitter emits the given
+event or that is rejected if the EventEmitter emits 'error' while waiting.
+The Promise will resolve with an array of all the arguments emitted to the
+given event.
This method is intentionally generic and works with the web platform EventTarget interface, which has no special'error' event
+semantics and does not listen to the 'error' event.
import { once, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
process.nextTick(() => {
ee.emit('myevent', 42);
});
const [value] = await once(ee, 'myevent');
console.log(value);
const err = new Error('kaboom');
process.nextTick(() => {
ee.emit('error', err);
});
try {
await once(ee, 'myevent');
} catch (err) {
console.error('error happened', err);
}
+The special handling of the 'error' event is only used when events.once() is used to wait for another event. If events.once() is used to wait for the
+'error' event itself, then it is treated as any other kind of event without
+special handling:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
once(ee, 'error')
.then(([err]) => console.log('ok', err.message))
.catch((err) => console.error('error', err.message));
ee.emit('error', new Error('boom'));
// Prints: ok boom
+An AbortSignal can be used to cancel waiting for the event:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
const ac = new AbortController();
async function foo(emitter, event, signal) {
try {
await once(emitter, event, { signal });
console.log('event emitted!');
} catch (error) {
if (error.name === 'AbortError') {
console.error('Waiting for the event was canceled!');
} else {
console.error('There was an error', error.message);
}
}
}
foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
+Optionaloptions: StaticEventEmitterOptionsCreates a Promise that is fulfilled when the EventEmitter emits the given
+event or that is rejected if the EventEmitter emits 'error' while waiting.
+The Promise will resolve with an array of all the arguments emitted to the
+given event.
This method is intentionally generic and works with the web platform EventTarget interface, which has no special'error' event
+semantics and does not listen to the 'error' event.
import { once, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
process.nextTick(() => {
ee.emit('myevent', 42);
});
const [value] = await once(ee, 'myevent');
console.log(value);
const err = new Error('kaboom');
process.nextTick(() => {
ee.emit('error', err);
});
try {
await once(ee, 'myevent');
} catch (err) {
console.error('error happened', err);
}
+The special handling of the 'error' event is only used when events.once() is used to wait for another event. If events.once() is used to wait for the
+'error' event itself, then it is treated as any other kind of event without
+special handling:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
once(ee, 'error')
.then(([err]) => console.log('ok', err.message))
.catch((err) => console.error('error', err.message));
ee.emit('error', new Error('boom'));
// Prints: ok boom
+An AbortSignal can be used to cancel waiting for the event:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
const ac = new AbortController();
async function foo(emitter, event, signal) {
try {
await once(emitter, event, { signal });
console.log('event emitted!');
} catch (error) {
if (error.name === 'AbortError') {
console.error('Waiting for the event was canceled!');
} else {
console.error('There was an error', error.message);
}
}
}
foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
+Optionaloptions: StaticEventEmitterOptionsStaticsetimport { setMaxListeners, EventEmitter } from 'node:events';
const target = new EventTarget();
const emitter = new EventEmitter();
setMaxListeners(5, target, emitter);
+Optionaln: numberA non-negative number. The maximum number of listeners per EventTarget event.
Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, n is set as the default max for all newly created {EventTarget} and {EventEmitter}
+objects.
AbstractBase class for all backend entities.
-OptionalblobOptionaldateOptionaldateOptionalisOptionalisOptionalutcProtectedbeccaProtected_getProtected_setProtectedbeforeOptionalopts: {}OptionalisDeleted: booleanAbstractgetProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
-This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
-Optionalopts: {}AbstractupdateAttachment represent data related/attached to the note. Conceptually similar to attributes, but intended for -larger amounts of data and generally not accessible to the user.
-OptionalattachmentOptionalblobOptionalcontentoptionally added to the entity
-OptionaldateOptionaldateOptionalisOptionalisOptionalisOptionalnoteeither noteId or revisionId to which this attachment belongs
-OptionalpositionOptionaltypeOptionalutcOptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryProtected_getProtected_setOptionalisDeleted: booleantrue if the note has string content (not binary)
-Mark the entity as (soft) deleted. It will be completely erased later.
-This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
-Optionalopts: {}Optionalopts: ContentOptsAttribute is an abstract concept which has two real uses - label (key - value pair) -and relation (representing named relationship between source and target note)
-Optionalrow: AttributeRowOptionalblobOptionaldateOptionaldateOptionalisOptionalisOptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryProtected_getProtected_setOptionalisInheritable: booleanOptionalisDeleted: booleanProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
-This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
-Optionalopts: {}Base class for all backend entities.
-OptionalblobOptionaldateOptionaldateOptionalisOptionalisOptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryProtected_getProtected_setProtectedbeforeOptionalopts: {}OptionalisDeleted: booleanProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
-This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
-Optionalopts: {}Branch represents a relationship between a child note and its parent note. Trilium allows a note to have multiple -parents.
-Note that you should not rely on the branch's identity, since it can change easily with a note's move. -Always check noteId instead.
-OptionalblobOptionalbranchOptionaldateOptionaldateOptionalisOptionalisOptionalutcProtectedbeccaBranch is weak when its existence should not hinder deletion of its note. -As a result, note with only weak branches should be immediately deleted. -An example is shared or bookmarked clones - they are created automatically and exist for technical reasons, -not as user-intended actions. From user perspective, they don't count as real clones and for the purpose -of deletion should not act as a clone.
-root branch will have undefined parent, all other branches have to have a parent note
-StaticentityStatichashedStaticprimaryProtected_getProtected_setOptionalnotePosition: numberDelete a branch. If this is a last note's branch, delete the note as well.
-OptionaldeleteId: stringoptional delete identified
-OptionaltaskContext: TaskContexttrue if note has been deleted, false otherwise
-OptionalisDeleted: booleanProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
-This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
-Optionalopts: {}EtapiToken is an entity representing token used to authenticate against Trilium REST API from client applications. -Used by:
-The format user is presented with is "
Optionalrow: EtapiTokenRowOptionalblobOptionaldateOptionaldateOptionaletapiOptionalisOptionalisOptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryProtected_getProtected_setOptionalisDeleted: booleanProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
-This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
-Optionalopts: {}Trilium's main entity, which can represent text note, image, code note, file attachment etc.
-Optionalblobsize of the note content, attachment contents and revision contents in bytes
-size of the note content, attachment contents in bytes
-size of the content in bytes
-OptionaldateOptionaldateset during the deletion operation, before it is completed (removed from becca completely).
-OptionalisOptionalisnumber of note revisions for this note
-OptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryOptionaltype: null | stringOptionalname: null | stringProtected_getProtected_setAdds a new attribute to this note. The attribute is saved and returned. -See addLabel, addRelation for more specific methods.
-attribute type (label / relation)
-name of the attribute, not including the leading ~/#
-value of the attribute - text for labels, target note ID for relations; optional.
-Adds a new label to this note. The label attribute is saved and returned.
-name of the label, not including the leading #
-text value of the label; optional
-Adds a new relation to this note. The relation attribute is saved and -returned.
-name of the relation, not including the leading ~
-Some notes are eligible for conversion into an attachment of its parent, note must have these properties:
-Currently, works only for image notes.
-In the future, this functionality might get more generic and some of the requirements relaxed.
-null if note is not eligible for conversion
-(Soft) delete a note and all its descendants.
-optional delete identified
-OptionalisDeleted: booleanGives all possible note paths leading to this note. Paths containing search note are ignored (could form cycles)
-array of notePaths (each represented by array of noteIds constituting the particular note path)
-attribute type (label, relation, etc.)
-attribute name
-attribute of the given type and name. If there are more such attributes, first is returned. -Returns null if there's no such attribute belonging to this note.
-Beware that the method must not create a copy of the array, but actually returns its internal array -(for performance reasons)
-Optionaltype: string(optional) attribute type to filter
-Optionalname: string(optional) attribute name to filter
-all note's attributes, including inherited ones
-attribute type (label, relation, etc.)
-attribute name
-attribute value of given type and name or null if no such attribute exists.
-Returns a note path considered to be the "best"
-array of noteIds constituting the particular note path
-Returns a note path considered to be the "best"
-serialized note path (e.g. 'root/a1h315/js725h')
-Note content has quite special handling - it's not a separate entity, but a lazily loaded -part of Note entity with its own sync. Reasons behind this hybrid design has been:
-This is used for:
-returns only notes which are templated, does not include their subtrees -in effect returns notes which are influenced by note's non-inheritable attributes
-valid object or null if the content cannot be parsed as JSON
-Optionalname: stringlabel name to filter
-all note's labels (attributes with type label), including inherited ones
-label name
-label value if label exists, null otherwise
-label name to filter
-all note's label values, including inherited ones
-attribute belonging to this specific note (excludes inherited attributes)
-This method can be significantly faster than the getAttribute()
-Beware that the method must not create a copy of the array, but actually returns its internal array -(for performance reasons)
-(optional) attribute type to filter
-(optional) attribute name to filter
-(optional) attribute value to filter
-note's "owned" attributes - excluding inherited ones
-attribute type (label, relation, etc.)
-attribute name
-attribute value of given type and name or null if no such attribute exists.
-label name to filter
-all note's labels (attributes with type label), excluding inherited ones
-label name
-label value if label exists, null otherwise
-label name to filter
-all note's label values, excluding inherited ones
-Optionalname: null | stringrelation name to filter
-all note's relations (attributes with type relation), excluding inherited ones
-relation name
-relation value if relation exists, null otherwise
-Optionalname: stringrelation name to filter
-all note's relations (attributes with type relation), including inherited ones
-relation name
-relation value if relation exists, null otherwise
-JS script environment - either "frontend" or "backend"
-Returns strong (as opposed to weak) parent branches. See isWeak for details.
-includes the subtree root note as well
-label name
-Optionalvalue: stringlabel value
-true if label exists (including inherited)
-attribute name
-Optionalvalue: stringattribute value
-true if note has an attribute with given type and name (excluding inherited)
-label name
-Optionalvalue: stringlabel value
-true if label exists (excluding inherited)
-relation name
-Optionalvalue: stringrelation value
-true if relation exists (excluding inherited)
-relation name
-Optionalvalue: stringrelation value
-true if relation exists (including inherited)
-true if the note has string content (not binary)
-true if ancestorNoteId occurs in at least one of the note's paths
-boolean - true if there's no non-hidden path, note is not cloned to the visible tree
-true if this note is HTML
-true if this note is an image
-true if this note is JavaScript (code or attachment)
-true if this note is of application/json content type
-label name
-true if label exists (including inherited) and does not have "false" value.
-true if this note is the root of the note tree. Root note has "root" noteId
-Mark the entity as (soft) deleted. It will be completely erased later.
-This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputRemoves given attribute name-value pair if it exists.
-attribute type (label, relation, etc.)
-attribute name
-Optionalvalue: stringattribute value (optional)
-Remove label name-value pair, if it exists.
-label name
-Optionalvalue: stringlabel value
-Remove the relation name-value pair, if it exists.
-relation name
-Optionalvalue: stringrelation value (noteId)
-Saves entity - executes SQL, but doesn't commit the transaction on its own
-Optionalopts: {}choose by which property we detect if to update an existing attachment. -Supported values are either 'attachmentId' (default) or 'title'
-Update's given attribute's value or creates it if it doesn't exist
-attribute type (label, relation, etc.)
-attribute name
-Optionalvalue: stringattribute value (optional)
-Update's given label's value or creates it if it doesn't exist
-label name
-Optionalvalue: stringlabel value
-Update's given relation's value or creates it if it doesn't exist
-relation name
-Optionalvalue: stringrelation value (noteId)
-Based on enabled, the attribute is either set or removed.
-attribute type ('relation', 'label' etc.)
-toggle On or Off
-attribute name
-Optionalvalue: stringattribute value (optional)
-Based on enabled, label is either set or removed.
-toggle On or Off
-label name
-Optionalvalue: stringlabel value (optional)
-Based on enabled, relation is either set or removed.
-toggle On or Off
-relation name
-Optionalvalue: stringrelation value (noteId)
-Option represents a name-value pair, either directly configurable by the user or some system property.
-OptionalblobOptionaldateOptionaldateOptionalisOptionalisOptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryProtected_getProtected_setOptionalisDeleted: booleanProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
-This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
-Optionalopts: {}RecentNote represents recently visited note.
-OptionalblobOptionaldateOptionaldateOptionalisOptionalisOptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryProtected_getProtected_setProtectedbeforeOptionalopts: {}OptionalisDeleted: booleanProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
-This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
-Optionalopts: {}Revision represents a snapshot of note's title and content at some point in the past. -It's used for seamless note versioning.
-OptionalblobOptionalcontentOptionalcontentOptionaldateOptionaldateOptionaldateOptionalisOptionalisOptionalrevisionOptionalutcOptionalutcProtectedbeccaStaticentityStatichashedStaticprimaryProtected_getProtected_setRevisions are not soft-deletable, they are immediately hard-deleted (erased).
-OptionalisDeleted: booleanvalid object or null if the content cannot be parsed as JSON
-true if the note has string content (not binary)
-Mark the entity as (soft) deleted. It will be completely erased later.
-This is a low-level method, for notes and branches use note.deleteNote() and 'branch.deleteBranch()` instead.
ProtectedputSaves entity - executes SQL, but doesn't commit the transaction on its own
-Optionalopts: {}Optionaloptions: ParserOptionsThis object contains "at your risk" and "no BC guarantees" objects for advanced use cases.
+Axios library for HTTP requests. See https://axios-http.com for documentation
+cheerio library for HTML parsing and manipulation. See https://cheerio.js.org for documentation
+Note where the script is currently executing. This comes into play when your script is spread in multiple code +notes, the script starts in "startNote", but then through function calls may jump into another note (currentNote). +A similar concept in C would be FILE +Don't mix this up with the concept of active note.
+day.js library for date manipulation. See https://day.js.org for documentation
+OptionaloriginEntity whose event triggered this execution
+sql
+OptionalstartNote where the script started executing (entrypoint). +As an analogy, in C this would be the file which contains the main() function of the current process.
+xml2js library for XML parsing. See https://github.com/Leonidas-from-XIV/node-xml2js for documentation
+If the backupName is e.g. "now", then the backup will be written to "backup-now.db" file
+resolves once the backup is finished
+Create data note - data in this context means object serializable to JSON. Created note will be of type 'code' and +JSON MIME type. See also createNewNote() for more options.
+object contains newly created entities note and branch
+create new note under this parent
+Optionalattributes?: AttributeRow[]Optionaljson?: booleanshould the note be JSON
+object contains newly created entities note and branch
+Creates a new launcher to the launchbar. If the launcher (id) already exists, it will be updated.
+name of the boxicon to be used (e.g. "bx-time")
+id of the launcher, only alphanumeric at least 6 characters long
+if true, will be created in the "Visible launchers", otherwise in "Available launchers"
+will activate the target note/script upon pressing, e.g. "ctrl+e"
+for type "script"
+for type "note"
+one of
+OptionalwidgetNoteId?: stringfor type "customWidget"
+Create text note. See also createNewNote() for more options.
+If there's a branch between note and parent note, remove it. Otherwise, do nothing.
+If there's no branch between note and parent note, create one. Otherwise, do nothing. Returns the new or existing branch.
+if branch is created between note and parent note, set this prefix
+escaped string
+Instance name identifies particular Trilium instance. It can be useful for scripts +if some action needs to happen on only one specific instance.
+Retrieves notes with given label name & value
+attribute name
+Optionalvalue: stringattribute value
+Retrieves first note with given label name & value
+attribute name
+Optionalvalue: stringattribute value
+Returns root note of the calendar.
+Log given message to trilium logs and log pane in UI
+Return randomly generated string of given length. This random string generation is NOT cryptographically secure.
+of the string
+random string
+Executes given anonymous function on the frontend(s). +Internally, this serializes the anonymous function into string and sends it to frontend(s) via WebSocket. +Note that there can be multiple connected frontend instances (e.g. in different tabs). In such case, all +instances execute the given function.
+script to be executed on the frontend
+list of parameters to the anonymous function to be sent to frontend
+no return value is provided.
+Sync process can make data intermittently inconsistent. Scripts which require strong data consistency +can use this function to wait for a possible sync process to finish and prevent new sync process from starting +while it is running.
+Because this is an async process, the inner callback doesn't have automatic transaction handling, so in case +you need to make some DB changes, you need to surround your call with api.transactional(...)
+function to be executed while sync process is not running
+resolves once the callback is finished (callback is awaited)
+This is a powerful search method - you can search by attributes and their values, e.g.: +"#dateModified =* MONTH AND #log". See https://triliumnext.github.io/Docs/Wiki/search.html for full documentation for all options
+This is a powerful search method - you can search by attributes and their values, e.g.: +"#dateModified =* MONTH AND #log". See https://triliumnext.github.io/Docs/Wiki/search.html for full documentation for all options
+This method finds note by its noteId and prefix and either sets it to the given parentNoteId +or removes the branch (if parentNoteId is not given).
+This method looks similar to toggleNoteInParent() but differs because we're looking up branch by prefix.
+Sort child notes of a given note.
+OptionalfoldersFirst?: booleanOptionalreverse?: booleanOptionalsortBy?: string'title', 'dateCreated', 'dateModified' or a label name +See https://triliumnext.github.io/Docs/Wiki/sorting.html for details.
+Based on the value, either create or remove branch between note and parent note.
+true if we want the branch to exist, false if we want it gone
+if branch is created between note and parent note, set this prefix
+This functions wraps code which is supposed to be running in transaction. If transaction already +exists, then we'll use that transaction.
+result of func callback
+to unescape
+unescaped string
+OptionalrequireDisables automatic emitDestroy when the object is garbage collected.
+This usually does not need to be set (even if emitDestroy is called
+manually), unless the resource's asyncId is retrieved and the
+sensitive API's emitDestroy is called with it.
OptionaltriggerThe ID of the execution context that created this async event.
+OptionalattachmentOptionalblobOptionalcontentOptionalcontentOptionaldateOptionaldeleteOptionalisOptionalisOptionalownerOptionalpositionOptionalutcOptionalutcConstruct a type with the properties of T except for those in type K.
+OptionaladapterOptionalallowOptionalauthOptionalbaseURLOptionalbeforeOptionalcancelOptionaldataOptionaldecompressOptionalenvOptionalfamilyOptionalfetchOptionalformOptionalhttpOptionalhttpsOptionalinsecureHTTPParserOptionallookupOptionalmaxOptionalmaxOptionalmaxOptionalmaxOptionalmethodOptionalonOptionalonOptionalparamsOptionalparamsOptionalproxyOptionalresponseOptionalresponseOptionalsignalOptionalsocketOptionaltimeoutOptionaltimeoutOptionaltransformOptionaltransformOptionaltransitionalOptionaltransportOptionalurlOptionalvalidateOptionalwithOptionalwithXSRFTokenOptionalxsrfOptionalxsrfOptionalconfig: AxiosRequestConfig<D>Optionalconfig: AxiosRequestConfig<D>Optionalconfig: AxiosRequestConfig<D>Optionalconfig: AxiosRequestConfig<any>Optionalconfig: AxiosRequestConfig<D>Optionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>OptionaladapterOptionalallowOptionalauthOptionalbaseURLOptionalbeforeOptionalcancelOptionaldataOptionaldecompressOptionalenvOptionalfamilyOptionalfetchOptionalformOptionalheadersOptionalhttpOptionalhttpsOptionalinsecureHTTPParserOptionallookupOptionalmaxOptionalmaxOptionalmaxOptionalmaxOptionalmethodOptionalonOptionalonOptionalparamsOptionalparamsOptionalproxyOptionalresponseOptionalresponseOptionalsignalOptionalsocketOptionaltimeoutOptionaltimeoutOptionaltransformOptionaltransformOptionaltransitionalOptionaltransportOptionalurlOptionalvalidateOptionalwithOptionalwithXSRFTokenOptionalxsrfOptionalxsrfOptionalrequestOptionalstatus: numberOptionalconfig: AxiosRequestConfig<D>ReadonlyVERSIONOptionalconfig: CreateAxiosDefaults<any>Optionalconfig: AxiosRequestConfig<D>Optionalconfig: AxiosRequestConfig<D>Optionalconfig: AxiosRequestConfig<any>Optionalconfig: AxiosRequestConfig<D>Optionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>Optionaldata: DOptionalconfig: AxiosRequestConfig<D>OptionalbranchOptionalisOptionalisOptionalnoteOptionalprefixOptionalutcCurrent column number [if this function was defined in a script]
+A call site object representing the location where eval was called +[if this function was created using a call to eval]
+Name of the script [if this function was defined in a script]
+Current function
+Name of the current function, typically its name property. +If a name property is not available an attempt will be made to try +to infer a name from the function's context.
+Current line number [if this function was defined in a script]
+Name of the property [of "this" or one of its prototypes] that holds +the current function
+returns the index of the promise element that was followed in +Promise.all() or Promise.any() for async stack traces, or null +if the CallSite is not an async
+Value of "this"
+Type of "this" as a string. +This is the name of the function stored in the constructor field of +"this", if available. Otherwise the object's [[Class]] internal +property.
+is this an async call (i.e. await, Promise.all(), or Promise.any())?
+Is this a constructor call?
+Does this call take place in code defined by a call to eval?
+Is this call in native V8 code?
+is this an async call to Promise.all()?
+Is this a toplevel invocation, that is, is "this" the global object?
+Optionalmessage: stringOptionalconfig: AxiosRequestConfig<any>Optionalrequest: anyOptionalselector: stringOptionalpropertyName: stringOptionalselector: stringOptionalselector: stringOptionalfilter: stringOptionalselector: stringOptionalselector: stringOptionalselector: stringOptionalfilter: stringOptionalselector: stringOptionalselector: stringOptionalfilter: stringOptionalselector: stringOptionalselector: stringOptionalend: numberOptionaltoggleSwitch: booleanOptionaltoggleSwitch: booleanOptionaloptions: CheerioParserOptionsOptionaloptions: CheerioParserOptionsOptionaloptions: CheerioParserOptionsOptionaloptions: CheerioParserOptionsOptionalcontext: null | DocumentOptionalkeepScripts: booleanOptional_useOptionaldecodeOptionalignoreOptionallowerOptionallowerOptionalnormalizeOptionalrecognizeCDATAOptionalrecognizeOptionalwithOptionalwithOptionalxmlConstruct a type with the properties of T except for those in type K.
+OptionaladapterOptionalallowOptionalauthOptionalbaseURLOptionalbeforeOptionalcancelOptionaldataOptionaldecompressOptionalenvOptionalfamilyOptionalfetchOptionalformOptionalheadersOptionalhttpOptionalhttpsOptionalinsecureHTTPParserOptionallookupOptionalmaxOptionalmaxOptionalmaxOptionalmaxOptionalmethodOptionalonOptionalonOptionalparamsOptionalparamsOptionalproxyOptionalresponseOptionalresponseOptionalsignalOptionalsocketOptionaltimeoutOptionaltimeoutOptionaltransformOptionaltransformOptionaltransitionalOptionaltransportOptionalurlOptionalvalidateOptionalwithOptionalwithXSRFTokenOptionalxsrfOptionalxsrfOptionaloptions: ParamsSerializerOptionsOptionalcaptureEnables automatic capturing of promise rejection.
+OptionalnameThe type of async event, this is required when instantiating EventEmitterAsyncResource
+directly rather than as a child class.
OptionalrequireDisables automatic emitDestroy when the object is garbage collected.
+This usually does not need to be set (even if emitDestroy is called
+manually), unless the resource's asyncId is retrieved and the
+sensitive API's emitDestroy is called with it.
OptionaltriggerThe ID of the execution context that created this async event.
+The class AsyncResource is designed to be extended by the embedder's async
+resources. Using this, users can easily trigger the lifetime events of their
+own resources.
The init hook will trigger when an AsyncResource is instantiated.
The following is an overview of the AsyncResource API.
import { AsyncResource, executionAsyncId } from 'node:async_hooks';
// AsyncResource() is meant to be extended. Instantiating a
// new AsyncResource() also triggers init. If triggerAsyncId is omitted then
// async_hook.executionAsyncId() is used.
const asyncResource = new AsyncResource(
type, { triggerAsyncId: executionAsyncId(), requireManualDestroy: false },
);
// Run a function in the execution context of the resource. This will
// * establish the context of the resource
// * trigger the AsyncHooks before callbacks
// * call the provided function `fn` with the supplied arguments
// * trigger the AsyncHooks after callbacks
// * restore the original execution context
asyncResource.runInAsyncScope(fn, thisArg, ...args);
// Call AsyncHooks destroy callbacks.
asyncResource.emitDestroy();
// Return the unique ID assigned to the AsyncResource instance.
asyncResource.asyncId();
// Return the trigger ID for the AsyncResource instance.
asyncResource.triggerAsyncId();
+The unique asyncId assigned to the resource.
Call all destroy hooks. This should only ever be called once. An error will
+be thrown if it is called more than once. This must be manually called. If
+the resource is left to be collected by the GC then the destroy hooks will
+never be called.
A reference to asyncResource.
Call the provided function with the provided arguments in the execution context +of the async resource. This will establish the context, trigger the AsyncHooks +before callbacks, call the function, trigger the AsyncHooks after callbacks, and +then restore the original execution context.
+The same triggerAsyncId that is passed to the AsyncResource constructor.
Optional[captureSynchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments
+to each.
Returns true if the event had listeners, false otherwise.
import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();
// First listener
myEmitter.on('event', function firstListener() {
console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
const parameters = args.join(', ');
console.log(`event with parameters ${parameters} in third listener`);
});
console.log(myEmitter.listeners('event'));
myEmitter.emit('event', 1, 2, 3, 4, 5);
// Prints:
// [
// [Function: firstListener],
// [Function: secondListener],
// [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
+Returns an array listing the events for which the emitter has registered
+listeners. The values in the array are strings or Symbols.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
+Returns the current max listener value for the EventEmitter which is either
+set by emitter.setMaxListeners(n) or defaults to EventEmitter.defaultMaxListeners.
Returns the number of listeners listening for the event named eventName.
+If listener is provided, it will return how many times the listener is found
+in the list of the listeners of the event.
Adds the listener function to the end of the listeners array for the event
+named eventName. No checks are made to see if the listener has already
+been added. Multiple calls passing the same combination of eventName and
+listener will result in the listener being added, and called, multiple times.
server.on('connection', (stream) => {
console.log('someone connected!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the
+event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
+Adds a one-time listener function for the event named eventName. The
+next time eventName is triggered, this listener is removed and then invoked.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the
+event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
+Adds the listener function to the beginning of the listeners array for the
+event named eventName. No checks are made to see if the listener has
+already been added. Multiple calls passing the same combination of eventName
+and listener will result in the listener being added, and called, multiple times.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
Adds a one-timelistener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this
+listener is removed, and then invoked.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
Returns a copy of the array of listeners for the event named eventName,
+including any wrappers (such as those created by .once()).
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
+Removes all listeners, or those of the specified eventName.
It is bad practice to remove listeners added elsewhere in the code,
+particularly when the EventEmitter instance was created by some other
+component or module (e.g. sockets or file streams).
Returns a reference to the EventEmitter, so that calls can be chained.
Removes the specified listener from the listener array for the event named eventName.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
+removeListener() will remove, at most, one instance of a listener from the
+listener array. If any single listener has been added multiple times to the
+listener array for the specified eventName, then removeListener() must be
+called multiple times to remove each instance.
Once an event is emitted, all listeners attached to it at the
+time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution
+will not remove them fromemit() in progress. Subsequent events behave as expected.
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
+Because listeners are managed using an internal array, calling this will
+change the position indices of any listener registered after the listener
+being removed. This will not impact the order in which listeners are called,
+but it means that any copies of the listener array as returned by
+the emitter.listeners() method will need to be recreated.
When a single function has been added as a handler multiple times for a single
+event (as in the example below), removeListener() will remove the most
+recently added instance. In the example the once('ping') listener is removed:
import { EventEmitter } from 'node:events';
const ee = new EventEmitter();
function pong() {
console.log('pong');
}
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
ee.emit('ping');
ee.emit('ping');
+Returns a reference to the EventEmitter, so that calls can be chained.
By default EventEmitters will print a warning if more than 10 listeners are
+added for a particular event. This is a useful default that helps finding
+memory leaks. The emitter.setMaxListeners() method allows the limit to be
+modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.
Returns a reference to the EventEmitter, so that calls can be chained.
OptionallinkOptionaloptionsOptionalpurgeOptionalunlinkOptionaladapterOptionalallowOptionalauthOptionalbaseURLOptionalbeforeOptionalcancelOptionaldataOptionaldecompressOptionalenvOptionalfamilyOptionalfetchOptionalformOptionalhttpOptionalhttpsOptionalinsecureHTTPParserOptionallookupOptionalmaxOptionalmaxOptionalmaxOptionalmaxOptionalmethodOptionalonOptionalonOptionalparamsOptionalparamsOptionalproxyOptionalresponseOptionalresponseOptionalsignalOptionalsocketOptionaltimeoutOptionaltimeoutOptionaltransformOptionaltransformOptionaltransitionalOptionaltransportOptionalurlOptionalvalidateOptionalwithOptionalwithXSRFTokenOptionalxsrfOptionalxsrfDescribes a user-defined Iterator that is also iterable.
+OptionalreturnOptionalvalue: TReturnOptionalthrowOptionale: anyOptionalreturnOptionalvalue: TReturnOptionalthrowOptionale: anyOptionalbranchOptionaldateOptionalignoreOptionalisdefault is false
+Optionalisdefault is false
+Optionalmimedefault value is derived from default mimes for type
+Optionalnoteoptionally can force specific noteId
+Optionalnotedefault is the last existing notePosition in a parent + 10
+Optionalprefixdefault is empty string
+OptionaltargetOptionaltemplatetext, code, file, image, search, book, relationMap, canvas, webView
+OptionalutcOptionalblobOptionaldateOptionaldateOptionalisOptionaltitleOptionalutcOptionalcontentThe initial value of Object.prototype.constructor is the standard built-in Object constructor.
+Determines whether an object has a property with the specified name.
+A property name.
+Determines whether an object exists in another object's prototype chain.
+Another object whose prototype chain is to be checked.
+Determines whether a specified property is enumerable.
+A property name.
+Returns a date converted to a string using the current locale.
+Returns a string representation of an object.
+Returns the primitive value of the specified object.
+Database representation of an option.
+Options are key-value pairs that are used to store information such as user preferences (for example +the current theme, sync server information), but also information about the state of the application).
+OptionalblobOptionalcontentOptionaldateOptionalisOptionalrevisionOptionalutcOptionaloptions: CheerioParserOptionsOptionaloptions: CheerioParserOptionsOptionalcontext: null | DocumentOptionalkeepScripts: booleanAn instance of the frontend api available globally.
+OptionalcloseNames of events that will end the iteration.
+OptionalhighThe high watermark. The emitter is paused every time the size of events being buffered is higher than it.
+Supported only on emitters implementing pause() and resume() methods.
OptionallowThe low watermark. The emitter is resumed every time the size of events being buffered is lower than it.
+Supported only on emitters implementing pause() and resume() methods.
OptionalsignalCan be used to cancel awaiting events.
+OptionaldataOptionalendOptionalstartOptionalasyncOptionalattrkeyOptionalattrOptionalattrOptionalcharkeyOptionalcharsOptionalchildkeyOptionalchunkOptionalemptyOptionalexplicitOptionalexplicitOptionalexplicitOptionalexplicitOptionalignoreOptionalincludeOptionalmergeOptionalnormalizeOptionalnormalizeOptionalpreserveOptionalstrictOptionaltagOptionaltrimOptionalvalidatorOptionalvalueOptionalxmlnsOptionalattachmentOptionalblobOptionalcontentOptionalcontentOptionaldateOptionaldeleteOptionalisOptionalisOptionalownerOptionalpositionOptionalutcOptionalutcOptionalbranchOptionalisOptionalisOptionalnoteOptionalprefixOptionalutcOptionalcontentDatabase representation of an option.
-Options are key-value pairs that are used to store information such as user preferences (for example -the current theme, sync server information), but also information about the state of the application).
-OptionalblobOptionalcontentOptionaldateOptionalisOptionalrevisionOptionalutcOptionalonFulfilled: ((value: T) => T | Promise<T>) | nullOptionalonRejected: ((error: any) => any) | nullOptionaloptions: AxiosInterceptorOptionsProvides functionality common to all JavaScript objects.
+ConstThere are many different Note types, some of which are entirely opaque to the -end user. Those types should be used only for checking against, they are -not for direct use.
-Execute SQL
-Get a first column in an array.
-Get a map of first column mapping to second column.
-Get first returned row.
-Get all returned rows.
-Get single value from the given query - first column from first returned row.
-
Base class for all backend entities.
+