IDBPFEntry
DBPF.js v1.1.0 • Docs
DBPF.js v1.1.0 / DBPF / IDBPFEntry
Interface: IDBPFEntry
See
Extends
Omit
<DBPFEntry
,"constructor"
>
Properties
blob()
blob: (
refresh
?) =>Promise
<Blob
>
Retrive the DBPF resource as a Blob on demand. This is a memory-efficient way to handle the blobs read from the entry.
NOTE: This method is designed to be overwritten by plugins. While it is an option, it is not recommended, as overwriting this method in one plugin may break it for other plugins.
Parameters
• refresh?: boolean
Whether to refresh the blob. If set to true
, the blob will be re-read from the entry.
Returns
Promise
<Blob
>
A promise that resolves with a Blob of the DBPF resource.
Inherited from
Omit.blob
Defined in
group
readonly
group:number
The group id of the DBPF resource.
Inherited from
Omit.group
Defined in
init
init:
undefined
| () =>EventedPromise
<void
>
Initializes the DBPF Entry asynchronously, evented.
Inherited from
Omit.init
Defined in
instance
readonly
instance:number
|bigint
The instance id of the DBPF resource.
Inherited from
Omit.instance
Defined in
mimetype
mimetype:
undefined
|string
Inherited from
Omit.mimetype
Defined in
offset
readonly
offset:number
The offset of the DBPF resource in the DBPF file.
Inherited from
Omit.offset
Defined in
reader
readonly
reader:BufferReader
The buffer reader for the DBPF resource.
Inherited from
Omit.reader
Defined in
size
readonly
size:object
The compression information about the DBPF resource.
file
file:
object
The amount of bytes the DBPF resource takes up in the DBPF file.
file.raw
raw:
number
file.reduced
reduced:
number
flag?
optional
flag:number
The compression flag of the DBPF resource.
memory?
optional
memory:number
The amount of bytes the DBPF resource takes up uncompressed in memory.
Inherited from
Omit.size
Defined in
type
readonly
type:number
The type id of the DBPF resource.
Inherited from
Omit.type
Defined in
Methods
[captureRejectionSymbol]()?
optional
[captureRejectionSymbol]<K
>(error
,event
, ...args
):void
Type Parameters
• K
Parameters
• error: Error
• event: string
| symbol
• ...args: AnyRest
Returns
void
Inherited from
Omit.[captureRejectionSymbol]
Defined in
node_modules/@types/node/events.d.ts:136
addListener()
addListener<
K
>(eventName
,listener
):this
Alias for emitter.on(eventName, listener)
.
Type Parameters
• K
Parameters
• eventName: string
| symbol
• listener
Returns
this
Since
v0.1.26
Inherited from
Omit.addListener
Defined in
node_modules/@types/node/events.d.ts:597
emit()
emit<
K
>(eventName
, ...args
):boolean
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
Type Parameters
• K
Parameters
• eventName: string
| symbol
• ...args: AnyRest
Returns
boolean
Since
v0.1.26
Inherited from
Omit.emit
Defined in
node_modules/@types/node/events.d.ts:859
eventNames()
eventNames(): (
string
|symbol
)[]
Returns an array listing the events for which the emitter has registered
listeners. The values in the array are strings or Symbol
s.
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
(string
| symbol
)[]
Since
v6.0.0
Inherited from
Omit.eventNames
Defined in
node_modules/@types/node/events.d.ts:922
getMaxListeners()
getMaxListeners():
number
Returns the current max listener value for the EventEmitter
which is either
set by emitter.setMaxListeners(n)
or defaults to defaultMaxListeners.
Returns
number
Since
v1.0.0
Inherited from
Omit.getMaxListeners
Defined in
node_modules/@types/node/events.d.ts:774
listenerCount()
listenerCount<
K
>(eventName
,listener
?):number
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.
Type Parameters
• K
Parameters
• eventName: string
| symbol
The name of the event being listened for
• listener?: Function
The event handler function
Returns
number
Since
v3.2.0
Inherited from
Omit.listenerCount
Defined in
node_modules/@types/node/events.d.ts:868
listeners()
listeners<
K
>(eventName
):Function
[]
Returns a copy of the array of listeners for the event named eventName
.
server.on('connection', (stream) => {
console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
Type Parameters
• K
Parameters
• eventName: string
| symbol
Returns
Function
[]
Since
v0.1.26
Inherited from
Omit.listeners
Defined in
node_modules/@types/node/events.d.ts:787
off()
off<
K
>(eventName
,listener
):this
Alias for emitter.removeListener()
.
Type Parameters
• K
Parameters
• eventName: string
| symbol
• listener
Returns
this
Since
v10.0.0
Inherited from
Omit.off
Defined in
node_modules/@types/node/events.d.ts:747
on()
on<
K
>(eventName
,listener
):this
Adds the listener
function to the end of the listeners array for the event
named eventName
. No checks are made to see if the listener
has already
been added. Multiple calls passing the same combination of eventName
and
listener
will result in the listener
being added, and called, multiple times.
server.on('connection', (stream) => {
console.log('someone connected!');
});
Returns a reference to the EventEmitter
, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependListener()
method can be used as an alternative to add the
event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
Type Parameters
• K
Parameters
• eventName: string
| symbol
The name of the event.
• listener
The callback function
Returns
this
Since
v0.1.101
Inherited from
Omit.on
Defined in
node_modules/@types/node/events.d.ts:629
once()
once<
K
>(eventName
,listener
):this
Adds a one-time listener
function for the event named eventName
. The
next time eventName
is triggered, this listener is removed and then invoked.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Returns a reference to the EventEmitter
, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener()
method can be used as an alternative to add the
event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
Type Parameters
• K
Parameters
• eventName: string
| symbol
The name of the event.
• listener
The callback function
Returns
this
Since
v0.3.0
Inherited from
Omit.once
Defined in
node_modules/@types/node/events.d.ts:659
prependListener()
prependListener<
K
>(eventName
,listener
):this
Adds the listener
function to the beginning of the listeners array for the
event named eventName
. No checks are made to see if the listener
has
already been added. Multiple calls passing the same combination of eventName
and listener
will result in the listener
being added, and called, multiple times.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
Returns a reference to the EventEmitter
, so that calls can be chained.
Type Parameters
• K
Parameters
• eventName: string
| symbol
The name of the event.
• listener
The callback function
Returns
this
Since
v6.0.0
Inherited from
Omit.prependListener
Defined in
node_modules/@types/node/events.d.ts:886
prependOnceListener()
prependOnceListener<
K
>(eventName
,listener
):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.
Type Parameters
• K
Parameters
• eventName: string
| symbol
The name of the event.
• listener
The callback function
Returns
this
Since
v6.0.0
Inherited from
Omit.prependOnceListener
Defined in
node_modules/@types/node/events.d.ts:902
rawListeners()
rawListeners<
K
>(eventName
):Function
[]
Returns a copy of the array of listeners for the event named eventName
,
including any wrappers (such as those created by .once()
).
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
Type Parameters
• K
Parameters
• eventName: string
| symbol
Returns
Function
[]
Since
v9.4.0
Inherited from
Omit.rawListeners
Defined in
node_modules/@types/node/events.d.ts:818
removeAllListeners()
removeAllListeners(
eventName
?):this
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.
Parameters
• eventName?: string
| symbol
Returns
this
Since
v0.1.26
Inherited from
Omit.removeAllListeners
Defined in
node_modules/@types/node/events.d.ts:758
removeListener()
removeListener<
K
>(eventName
,listener
):this
Removes the specified listener
from the listener array for the event named eventName
.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
removeListener()
will remove, at most, one instance of a listener from the
listener array. If any single listener has been added multiple times to the
listener array for the specified eventName
, then removeListener()
must be
called multiple times to remove each instance.
Once an event is emitted, all listeners attached to it at the
time of emitting are called in order. This implies that any removeListener()
or removeAllListeners()
calls after emitting and before the last listener finishes execution
will not remove them fromemit()
in progress. Subsequent events behave as expected.
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
Because listeners are managed using an internal array, calling this will
change the position indices of any listener registered after the listener
being removed. This will not impact the order in which listeners are called,
but it means that any copies of the listener array as returned by
the emitter.listeners()
method will need to be recreated.
When a single function has been added as a handler multiple times for a single
event (as in the example below), removeListener()
will remove the most
recently added instance. In the example the once('ping')
listener is removed:
import { EventEmitter } from 'node:events';
const ee = new EventEmitter();
function pong() {
console.log('pong');
}
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
ee.emit('ping');
ee.emit('ping');
Returns a reference to the EventEmitter
, so that calls can be chained.
Type Parameters
• K
Parameters
• eventName: string
| symbol
• listener
Returns
this
Since
v0.1.26
Inherited from
Omit.removeListener
Defined in
node_modules/@types/node/events.d.ts:742
setMaxListeners()
setMaxListeners(
n
):this
By default EventEmitter
s 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.
Parameters
• n: number
Returns
this
Since
v0.3.5
Inherited from
Omit.setMaxListeners
Defined in
node_modules/@types/node/events.d.ts:768