AbstractAbstractBase class for all backend entities.
+OptionalblobOptionaldateOptionaldateOptionalisOptionalisOptionalutcProtectedbeccaProtected_getProtected_setProtectedbeforeOptionalopts: {}OptionalisDeleted: booleanAbstractgetProtectedgetMark the entity as (soft) deleted. It will be completely erased later.
+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: {}AbstractupdateProtectedputSaves 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
+
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.
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 +
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.
Binds the given function to execute to this AsyncResource's scope.
The function to bind to the current AsyncResource.
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 +
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.
StaticbindBinds the given function to the current execution context.
The function to bind to the current execution context.
diff --git a/docs/backend_api/classes/Backend_Script_API._internal_.Axios.html b/docs/backend_api/classes/Backend_Script_API._internal_.Axios.html new file mode 100644 index 0000000000..f58babc744 --- /dev/null +++ b/docs/backend_api/classes/Backend_Script_API._internal_.Axios.html @@ -0,0 +1,16 @@ +Optionalconfig: 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.
-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. +
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)
+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.
+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 +
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:
+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.
+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)
+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 type (label, relation, etc.)
attribute name
-attribute of the given type and name. If there are more such attributes, first is returned. +
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 +
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.)
+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"
+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"
+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 +
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:
+This is used for:
returns only notes which are templated, does not include their subtrees +
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
+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
+label name to filter
all note's label values, including inherited ones
-attribute belonging to this specific note (excludes inherited attributes)
+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 +
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.)
+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 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
+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 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 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
+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
+attribute name
Optionalvalue: stringattribute value
true if note has an attribute with given type and name (excluding inherited)
-label name
+label name
Optionalvalue: stringlabel value
true if label exists (excluding inherited)
-relation name
+relation name
Optionalvalue: stringrelation value
true if relation exists (excluding inherited)
-relation name
+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 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.
+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.
+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.
+Remove label name-value pair, if it exists.
label name
Optionalvalue: stringlabel value
-Remove the relation name-value pair, if it exists.
+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. +
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.)
+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
+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
+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.)
+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.
+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.
+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
+
Integrates 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');
});
@@ -7,7 +7,7 @@ of events.EventEmitterAsyncResource will run within its async
The EventEmitterAsyncResource class has the same methods and takes the
same options as EventEmitter and AsyncResource themselves.
EventEmitter and AsyncResource themsel
on
once
setOptionaloptions: EventEmitterAsyncResourceOptionsOnly optional in child class.
-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')
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
+
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
@@ -75,20 +75,20 @@ 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.
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.
Synchronously 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
+
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.
Symbols.
Returns the current max listener value for the EventEmitter which is either
-set by emitter.setMaxListeners(n) or defaults to EventEmitter.defaultMaxListeners.
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.
+
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.
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] ]
Alias for emitter.removeListener().
Adds the listener function to the end of the listeners array for 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.
The name of the event.
The callback function
Adds a one-time listener function for the event named eventName. The
+
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!');
});
The name of the event.
The callback function
Adds the listener function to the beginning of the listeners array for the
+
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.
listener will result in the listener being added,
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
+
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!');
});
The name of the event.
The callback function
Returns a copy of the array of listeners for the event named eventName,
+
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.
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.
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);
once('ping') listener i
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
+
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.
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
@@ -222,9 +222,9 @@ not prevent the listener from running.
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.
Disposable that removes the abort listener.
StaticgetReturns a copy of the array of listeners for the event named eventName.
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
@@ -232,8 +232,8 @@ 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.
+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
@@ -242,16 +242,16 @@ 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.
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 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
+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
@@ -266,9 +266,9 @@ composed of the emitted event arguments.
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
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
+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
@@ -283,9 +283,9 @@ composed of the emitted event arguments.
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
Optionaloptions: StaticEventEmitterIteratorOptionsAn AsyncIterator that iterates eventName events emitted by the emitter
StaticonceCreates a Promise that is fulfilled when the EventEmitter emits the given
+
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.
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
+
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.
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);
+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}
+
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:
The EventEmitter class is defined and exposed by the node:events module:
import { EventEmitter } from 'node:events';
'removeListener' when existing listeners are removed.
It supports the following option:
'removeListener' when existing listeners are removed.
on
once
setOptionaloptions: EventEmitterOptionsStaticcaptureValue: boolean
+Optionaloptions: EventEmitterOptionsStaticcaptureValue: boolean
Change the default captureRejections option on all new EventEmitter objects.
Static ReadonlycaptureValue: Symbol.for('nodejs.rejection')
name property is set to 'MaxListenersExceededWarning'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
+
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.
+
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.
Returns a copy of the array of listeners for the event named eventName.
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.
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
+
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!');
});
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
+
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.
listener will result in the listener being added,
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
+
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,
+
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);
once('ping') listener i
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.
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
@@ -208,9 +208,9 @@ not prevent the listener from running.
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.
Disposable that removes the abort listener.
StaticgetReturns a copy of the array of listeners for the event named eventName.
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
@@ -218,8 +218,8 @@ 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.
+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
@@ -228,16 +228,16 @@ 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.
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 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
+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
@@ -252,9 +252,9 @@ composed of the emitted event arguments.
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
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
+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
@@ -269,9 +269,9 @@ composed of the emitted event arguments.
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
Optionaloptions: StaticEventEmitterIteratorOptionsAn AsyncIterator that iterates eventName events emitted by the emitter
StaticonceCreates a Promise that is fulfilled when the EventEmitter emits the given
+
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.
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
+
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.
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);
+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}
+
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:
The EventEmitter class is defined and exposed by the node:events module:
import { EventEmitter } from 'node:events';
'removeListener' when existing listeners are removed.
It supports the following option:
'removeListener' when existing listeners are removed.
on
once
setOptionaloptions: ParserOptionsStaticcaptureValue: boolean
+Optionaloptions: ParserOptionsStaticcaptureValue: boolean
Change the default captureRejections option on all new EventEmitter objects.
Static ReadonlycaptureValue: Symbol.for('nodejs.rejection')
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
+
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
@@ -68,42 +68,42 @@ 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.
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.
Synchronously 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 +
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 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.
+
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.
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] ]
Alias for emitter.removeListener().
Adds the listener function to the end of the listeners array for 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.
The name of the event.
The callback function
Adds a one-time listener function for the event named eventName. The
+
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!');
});
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
+
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.
listener will result in the listener being added,
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
+
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!');
});
The name of the event.
The callback function
Returns a copy of the array of listeners for the event named eventName,
+
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.
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.
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);
once('ping') listener i
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
+
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.
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
@@ -211,9 +211,9 @@ not prevent the listener from running.
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.
Disposable that removes the abort listener.
StaticgetReturns a copy of the array of listeners for the event named eventName.
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
@@ -221,8 +221,8 @@ 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.
+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
@@ -231,16 +231,16 @@ 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.
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 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
+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
@@ -255,9 +255,9 @@ composed of the emitted event arguments.
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
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
+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
@@ -272,9 +272,9 @@ composed of the emitted event arguments.
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
Optionaloptions: StaticEventEmitterIteratorOptionsAn AsyncIterator that iterates eventName events emitted by the emitter
StaticonceCreates a Promise that is fulfilled when the EventEmitter emits the given
+
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.
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
+
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.
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);
+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}
+
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.
Optionalconfig: 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: {}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: objectOptionalresult: 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: BuilderOptionsOptionaloptions: ParserOptionsOptionaloptions: 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
+This 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 +
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). +
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
+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 +
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
+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.
+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"
@@ -89,76 +89,76 @@ JSON MIME type. See also createNewNote() for more options.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.
-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
-Returns day note for given date. If such note doesn't exist, it is created.
+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.
-Returns month note for given date. If such a note doesn't exist, it is created.
+Retrieves notes with given label name & value
attribute name
Optionalvalue: stringattribute value
-Retrieves first note with given label name & value
+Retrieves first note with given label name & value
attribute name
Optionalvalue: stringattribute value
-Returns quarter note for given date. If such a note doesn't exist, it is created.
+Returns root note of the calendar.
-Returns root note of the calendar.
+Log given message to trilium logs and log pane in UI
-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). +
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 +
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.: +
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.: +
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 +
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.
+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 +
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
-OptionalrequireDisables automatic emitDestroy when the object is garbage collected.
This usually does not need to be set (even if emitDestroy is called
diff --git a/docs/backend_api/interfaces/backend_script_entrypoint._internal_.AttachmentOpts.html b/docs/backend_api/interfaces/Backend_Script_API._internal_.AttachmentOpts.html
similarity index 77%
rename from docs/backend_api/interfaces/backend_script_entrypoint._internal_.AttachmentOpts.html
rename to docs/backend_api/interfaces/Backend_Script_API._internal_.AttachmentOpts.html
index 52f2260cf9..847b1b238e 100644
--- a/docs/backend_api/interfaces/backend_script_entrypoint._internal_.AttachmentOpts.html
+++ b/docs/backend_api/interfaces/Backend_Script_API._internal_.AttachmentOpts.html
@@ -1,2 +1,2 @@
-
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>OptionalbranchOptionalisOptionalisOptionalnoteOptionalprefixOptionalutcOptionalbranchOptionalisOptionalisOptionalnoteOptionalprefixOptionalutcOptionalmessage: 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: booleanOptionalforcewill also save this BAttachment entity
+OptionalforceOptionalforcewill also save this BNote entity
+Construct 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
+
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.
emitter.setMaxListeners(n) or defaults to EventEmitter.defaultMaxListeners.
Returns the number of listeners listening for the event named eventName.
+
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.
Returns a copy of the array of listeners for the event named eventName.
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.
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
+
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!');
});
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
+
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.
listener will result in the listener being added,
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
+
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,
+
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);
once('ping') listener i
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
diff --git a/docs/backend_api/interfaces/backend_script_entrypoint._internal_.EventEmitterOptions.html b/docs/backend_api/interfaces/Backend_Script_API._internal_.EventEmitterOptions.html
similarity index 75%
rename from docs/backend_api/interfaces/backend_script_entrypoint._internal_.EventEmitterOptions.html
rename to docs/backend_api/interfaces/Backend_Script_API._internal_.EventEmitterOptions.html
index 22549f04bc..cadfeb0da0 100644
--- a/docs/backend_api/interfaces/backend_script_entrypoint._internal_.EventEmitterOptions.html
+++ b/docs/backend_api/interfaces/Backend_Script_API._internal_.EventEmitterOptions.html
@@ -1,3 +1,3 @@
-
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
-OptionalutcOptionalbranchOptionaldateOptionalignoreOptionalisdefault 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
+OptionalutcOptionalblobOptionaldateOptionaldateOptionalisOptionaltitleOptionalutcOptionalblobOptionaldateOptionaldateOptionalisOptionaltitleOptionalutcOptionalcontentThe 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 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.
+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.
diff --git a/docs/backend_api/interfaces/backend_script_entrypoint._internal_.OptionRow.html b/docs/backend_api/interfaces/Backend_Script_API._internal_.OptionRow.html similarity index 93% rename from docs/backend_api/interfaces/backend_script_entrypoint._internal_.OptionRow.html rename to docs/backend_api/interfaces/Backend_Script_API._internal_.OptionRow.html index 05612c86a5..60900b23f5 100644 --- a/docs/backend_api/interfaces/backend_script_entrypoint._internal_.OptionRow.html +++ b/docs/backend_api/interfaces/Backend_Script_API._internal_.OptionRow.html @@ -1,11 +1,11 @@ -Database representation of an option.
+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).
-The name of the option.
+OptionalutcThe value of the option.
+OptionalblobOptionalcontentOptionaldateOptionalisOptionalrevisionOptionalutcOptionalblobOptionalcontentOptionaldateOptionalisOptionalrevisionOptionalutcOptionaloptions: CheerioParserOptionsOptionaloptions: CheerioParserOptionsOptionalcontext: null | DocumentOptionalkeepScripts: booleanAn instance of the frontend api available globally.
+An instance of the frontend api available globally.
pause() and resume()<
OptionalsignalCan be used to cancel awaiting events.
-OptionaldataOptionalendOptionalstart
Base class for all backend entities.
-