694 lines
21 KiB
JavaScript
694 lines
21 KiB
JavaScript
var __defProp = Object.defineProperty;
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
|
|
// src/eventified.ts
|
|
var Eventified = class {
|
|
constructor(options) {
|
|
__publicField(this, "_eventListeners");
|
|
__publicField(this, "_maxListeners");
|
|
__publicField(this, "_logger");
|
|
__publicField(this, "_throwOnEmitError", false);
|
|
__publicField(this, "_throwOnEmptyListeners", false);
|
|
__publicField(this, "_errorEvent", "error");
|
|
this._eventListeners = /* @__PURE__ */ new Map();
|
|
this._maxListeners = 100;
|
|
this._logger = options?.logger;
|
|
if (options?.throwOnEmitError !== void 0) {
|
|
this._throwOnEmitError = options.throwOnEmitError;
|
|
}
|
|
if (options?.throwOnEmptyListeners !== void 0) {
|
|
this._throwOnEmptyListeners = options.throwOnEmptyListeners;
|
|
}
|
|
}
|
|
/**
|
|
* Gets the logger
|
|
* @returns {Logger}
|
|
*/
|
|
get logger() {
|
|
return this._logger;
|
|
}
|
|
/**
|
|
* Sets the logger
|
|
* @param {Logger} logger
|
|
*/
|
|
set logger(logger) {
|
|
this._logger = logger;
|
|
}
|
|
/**
|
|
* Gets whether an error should be thrown when an emit throws an error. Default is false and only emits an error event.
|
|
* @returns {boolean}
|
|
*/
|
|
get throwOnEmitError() {
|
|
return this._throwOnEmitError;
|
|
}
|
|
/**
|
|
* Sets whether an error should be thrown when an emit throws an error. Default is false and only emits an error event.
|
|
* @param {boolean} value
|
|
*/
|
|
set throwOnEmitError(value) {
|
|
this._throwOnEmitError = value;
|
|
}
|
|
/**
|
|
* Gets whether an error should be thrown when emitting 'error' event with no listeners. Default is false.
|
|
* @returns {boolean}
|
|
*/
|
|
get throwOnEmptyListeners() {
|
|
return this._throwOnEmptyListeners;
|
|
}
|
|
/**
|
|
* Sets whether an error should be thrown when emitting 'error' event with no listeners. Default is false.
|
|
* @param {boolean} value
|
|
*/
|
|
set throwOnEmptyListeners(value) {
|
|
this._throwOnEmptyListeners = value;
|
|
}
|
|
/**
|
|
* Adds a handler function for a specific event that will run only once
|
|
* @param {string | symbol} eventName
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
once(eventName, listener) {
|
|
const onceListener = (...arguments_) => {
|
|
this.off(eventName, onceListener);
|
|
listener(...arguments_);
|
|
};
|
|
this.on(eventName, onceListener);
|
|
return this;
|
|
}
|
|
/**
|
|
* Gets the number of listeners for a specific event. If no event is provided, it returns the total number of listeners
|
|
* @param {string} eventName The event name. Not required
|
|
* @returns {number} The number of listeners
|
|
*/
|
|
listenerCount(eventName) {
|
|
if (eventName === void 0) {
|
|
return this.getAllListeners().length;
|
|
}
|
|
const listeners = this._eventListeners.get(eventName);
|
|
return listeners ? listeners.length : 0;
|
|
}
|
|
/**
|
|
* Gets an array of event names
|
|
* @returns {Array<string | symbol>} An array of event names
|
|
*/
|
|
eventNames() {
|
|
return [...this._eventListeners.keys()];
|
|
}
|
|
/**
|
|
* Gets an array of listeners for a specific event. If no event is provided, it returns all listeners
|
|
* @param {string} [event] (Optional) The event name
|
|
* @returns {EventListener[]} An array of listeners
|
|
*/
|
|
rawListeners(event) {
|
|
if (event === void 0) {
|
|
return this.getAllListeners();
|
|
}
|
|
return this._eventListeners.get(event) ?? [];
|
|
}
|
|
/**
|
|
* Prepends a listener to the beginning of the listeners array for the specified event
|
|
* @param {string | symbol} eventName
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
prependListener(eventName, listener) {
|
|
const listeners = this._eventListeners.get(eventName) ?? [];
|
|
listeners.unshift(listener);
|
|
this._eventListeners.set(eventName, listeners);
|
|
return this;
|
|
}
|
|
/**
|
|
* Prepends a one-time listener to the beginning of the listeners array for the specified event
|
|
* @param {string | symbol} eventName
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
prependOnceListener(eventName, listener) {
|
|
const onceListener = (...arguments_) => {
|
|
this.off(eventName, onceListener);
|
|
listener(...arguments_);
|
|
};
|
|
this.prependListener(eventName, onceListener);
|
|
return this;
|
|
}
|
|
/**
|
|
* Gets the maximum number of listeners that can be added for a single event
|
|
* @returns {number} The maximum number of listeners
|
|
*/
|
|
maxListeners() {
|
|
return this._maxListeners;
|
|
}
|
|
/**
|
|
* Adds a listener for a specific event. It is an alias for the on() method
|
|
* @param {string | symbol} event
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
addListener(event, listener) {
|
|
this.on(event, listener);
|
|
return this;
|
|
}
|
|
/**
|
|
* Adds a listener for a specific event
|
|
* @param {string | symbol} event
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
on(event, listener) {
|
|
if (!this._eventListeners.has(event)) {
|
|
this._eventListeners.set(event, []);
|
|
}
|
|
const listeners = this._eventListeners.get(event);
|
|
if (listeners) {
|
|
if (listeners.length >= this._maxListeners) {
|
|
console.warn(
|
|
`MaxListenersExceededWarning: Possible event memory leak detected. ${listeners.length + 1} ${event} listeners added. Use setMaxListeners() to increase limit.`
|
|
);
|
|
}
|
|
listeners.push(listener);
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Removes a listener for a specific event. It is an alias for the off() method
|
|
* @param {string | symbol} event
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
removeListener(event, listener) {
|
|
this.off(event, listener);
|
|
return this;
|
|
}
|
|
/**
|
|
* Removes a listener for a specific event
|
|
* @param {string | symbol} event
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
off(event, listener) {
|
|
const listeners = this._eventListeners.get(event) ?? [];
|
|
const index = listeners.indexOf(listener);
|
|
if (index !== -1) {
|
|
listeners.splice(index, 1);
|
|
}
|
|
if (listeners.length === 0) {
|
|
this._eventListeners.delete(event);
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Calls all listeners for a specific event
|
|
* @param {string | symbol} event
|
|
* @param arguments_ The arguments to pass to the listeners
|
|
* @returns {boolean} Returns true if the event had listeners, false otherwise
|
|
*/
|
|
emit(event, ...arguments_) {
|
|
let result = false;
|
|
const listeners = this._eventListeners.get(event);
|
|
if (listeners && listeners.length > 0) {
|
|
for (const listener of listeners) {
|
|
listener(...arguments_);
|
|
result = true;
|
|
}
|
|
}
|
|
if (event === this._errorEvent) {
|
|
const error = arguments_[0] instanceof Error ? arguments_[0] : new Error(`${arguments_[0]}`);
|
|
if (this._throwOnEmitError && !result) {
|
|
throw error;
|
|
} else {
|
|
if (this.listeners(this._errorEvent).length === 0 && this._throwOnEmptyListeners === true) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
this.sendLog(event, arguments_);
|
|
return result;
|
|
}
|
|
/**
|
|
* Gets all listeners for a specific event. If no event is provided, it returns all listeners
|
|
* @param {string} [event] (Optional) The event name
|
|
* @returns {EventListener[]} An array of listeners
|
|
*/
|
|
listeners(event) {
|
|
return this._eventListeners.get(event) ?? [];
|
|
}
|
|
/**
|
|
* Removes all listeners for a specific event. If no event is provided, it removes all listeners
|
|
* @param {string} [event] (Optional) The event name
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
removeAllListeners(event) {
|
|
if (event !== void 0) {
|
|
this._eventListeners.delete(event);
|
|
} else {
|
|
this._eventListeners.clear();
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Sets the maximum number of listeners that can be added for a single event
|
|
* @param {number} n The maximum number of listeners
|
|
* @returns {void}
|
|
*/
|
|
setMaxListeners(n) {
|
|
this._maxListeners = n;
|
|
for (const listeners of this._eventListeners.values()) {
|
|
if (listeners.length > n) {
|
|
listeners.splice(n);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Gets all listeners
|
|
* @returns {EventListener[]} An array of listeners
|
|
*/
|
|
getAllListeners() {
|
|
let result = [];
|
|
for (const listeners of this._eventListeners.values()) {
|
|
result = [...result, ...listeners];
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Sends a log message using the configured logger based on the event name
|
|
* @param {string | symbol} eventName - The event name that determines the log level
|
|
* @param {unknown} data - The data to log
|
|
*/
|
|
sendLog(eventName, data) {
|
|
if (!this._logger) {
|
|
return;
|
|
}
|
|
let message;
|
|
if (typeof data === "string") {
|
|
message = data;
|
|
} else if (Array.isArray(data) && data.length > 0 && data[0] instanceof Error) {
|
|
message = data[0].message;
|
|
} else if (data instanceof Error) {
|
|
message = data.message;
|
|
} else if (Array.isArray(data) && data.length > 0 && typeof data[0]?.message === "string") {
|
|
message = data[0].message;
|
|
} else {
|
|
message = JSON.stringify(data);
|
|
}
|
|
switch (eventName) {
|
|
case "error": {
|
|
this._logger.error?.(message, { event: eventName, data });
|
|
break;
|
|
}
|
|
case "warn": {
|
|
this._logger.warn?.(message, { event: eventName, data });
|
|
break;
|
|
}
|
|
case "trace": {
|
|
this._logger.trace?.(message, { event: eventName, data });
|
|
break;
|
|
}
|
|
case "debug": {
|
|
this._logger.debug?.(message, { event: eventName, data });
|
|
break;
|
|
}
|
|
case "fatal": {
|
|
this._logger.fatal?.(message, { event: eventName, data });
|
|
break;
|
|
}
|
|
default: {
|
|
this._logger.info?.(message, { event: eventName, data });
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/index.ts
|
|
var Hookified = class extends Eventified {
|
|
constructor(options) {
|
|
super({
|
|
logger: options?.logger,
|
|
throwOnEmitError: options?.throwOnEmitError,
|
|
throwOnEmptyListeners: options?.throwOnEmptyListeners
|
|
});
|
|
__publicField(this, "_hooks");
|
|
__publicField(this, "_throwOnHookError", false);
|
|
__publicField(this, "_enforceBeforeAfter", false);
|
|
__publicField(this, "_deprecatedHooks");
|
|
__publicField(this, "_allowDeprecated", true);
|
|
this._hooks = /* @__PURE__ */ new Map();
|
|
this._deprecatedHooks = options?.deprecatedHooks ? new Map(options.deprecatedHooks) : /* @__PURE__ */ new Map();
|
|
if (options?.throwOnHookError !== void 0) {
|
|
this._throwOnHookError = options.throwOnHookError;
|
|
} else if (options?.throwHookErrors !== void 0) {
|
|
this._throwOnHookError = options.throwHookErrors;
|
|
}
|
|
if (options?.enforceBeforeAfter !== void 0) {
|
|
this._enforceBeforeAfter = options.enforceBeforeAfter;
|
|
}
|
|
if (options?.allowDeprecated !== void 0) {
|
|
this._allowDeprecated = options.allowDeprecated;
|
|
}
|
|
}
|
|
/**
|
|
* Gets all hooks
|
|
* @returns {Map<string, Hook[]>}
|
|
*/
|
|
get hooks() {
|
|
return this._hooks;
|
|
}
|
|
/**
|
|
* Gets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
|
|
* @returns {boolean}
|
|
* @deprecated - this will be deprecated in version 2. Please use throwOnHookError.
|
|
*/
|
|
get throwHookErrors() {
|
|
return this._throwOnHookError;
|
|
}
|
|
/**
|
|
* Sets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
|
|
* @param {boolean} value
|
|
* @deprecated - this will be deprecated in version 2. Please use throwOnHookError.
|
|
*/
|
|
set throwHookErrors(value) {
|
|
this._throwOnHookError = value;
|
|
}
|
|
/**
|
|
* Gets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
|
|
* @returns {boolean}
|
|
*/
|
|
get throwOnHookError() {
|
|
return this._throwOnHookError;
|
|
}
|
|
/**
|
|
* Sets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
|
|
* @param {boolean} value
|
|
*/
|
|
set throwOnHookError(value) {
|
|
this._throwOnHookError = value;
|
|
}
|
|
/**
|
|
* Gets whether to enforce that all hook names start with 'before' or 'after'. Default is false.
|
|
* @returns {boolean}
|
|
* @default false
|
|
*/
|
|
get enforceBeforeAfter() {
|
|
return this._enforceBeforeAfter;
|
|
}
|
|
/**
|
|
* Sets whether to enforce that all hook names start with 'before' or 'after'. Default is false.
|
|
* @param {boolean} value
|
|
*/
|
|
set enforceBeforeAfter(value) {
|
|
this._enforceBeforeAfter = value;
|
|
}
|
|
/**
|
|
* Gets the map of deprecated hook names to deprecation messages.
|
|
* @returns {Map<string, string>}
|
|
*/
|
|
get deprecatedHooks() {
|
|
return this._deprecatedHooks;
|
|
}
|
|
/**
|
|
* Sets the map of deprecated hook names to deprecation messages.
|
|
* @param {Map<string, string>} value
|
|
*/
|
|
set deprecatedHooks(value) {
|
|
this._deprecatedHooks = value;
|
|
}
|
|
/**
|
|
* Gets whether deprecated hooks are allowed to be registered and executed. Default is true.
|
|
* @returns {boolean}
|
|
*/
|
|
get allowDeprecated() {
|
|
return this._allowDeprecated;
|
|
}
|
|
/**
|
|
* Sets whether deprecated hooks are allowed to be registered and executed. Default is true.
|
|
* @param {boolean} value
|
|
*/
|
|
set allowDeprecated(value) {
|
|
this._allowDeprecated = value;
|
|
}
|
|
/**
|
|
* Validates hook event name if enforceBeforeAfter is enabled
|
|
* @param {string} event - The event name to validate
|
|
* @throws {Error} If enforceBeforeAfter is true and event doesn't start with 'before' or 'after'
|
|
*/
|
|
validateHookName(event) {
|
|
if (this._enforceBeforeAfter) {
|
|
const eventValue = event.trim().toLocaleLowerCase();
|
|
if (!eventValue.startsWith("before") && !eventValue.startsWith("after")) {
|
|
throw new Error(
|
|
`Hook event "${event}" must start with "before" or "after" when enforceBeforeAfter is enabled`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Checks if a hook is deprecated and emits a warning if it is
|
|
* @param {string} event - The event name to check
|
|
* @returns {boolean} - Returns true if the hook should proceed, false if it should be blocked
|
|
*/
|
|
checkDeprecatedHook(event) {
|
|
if (this._deprecatedHooks.has(event)) {
|
|
const message = this._deprecatedHooks.get(event);
|
|
const warningMessage = `Hook "${event}" is deprecated${message ? `: ${message}` : ""}`;
|
|
this.emit("warn", { hook: event, message: warningMessage });
|
|
return this._allowDeprecated;
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Adds a handler function for a specific event
|
|
* @param {string} event
|
|
* @param {Hook} handler - this can be async or sync
|
|
* @returns {void}
|
|
*/
|
|
onHook(event, handler) {
|
|
this.onHookEntry({ event, handler });
|
|
}
|
|
/**
|
|
* Adds a handler function for a specific event
|
|
* @param {HookEntry} hookEntry
|
|
* @returns {void}
|
|
*/
|
|
onHookEntry(hookEntry) {
|
|
this.validateHookName(hookEntry.event);
|
|
if (!this.checkDeprecatedHook(hookEntry.event)) {
|
|
return;
|
|
}
|
|
const eventHandlers = this._hooks.get(hookEntry.event);
|
|
if (eventHandlers) {
|
|
eventHandlers.push(hookEntry.handler);
|
|
} else {
|
|
this._hooks.set(hookEntry.event, [hookEntry.handler]);
|
|
}
|
|
}
|
|
/**
|
|
* Alias for onHook. This is provided for compatibility with other libraries that use the `addHook` method.
|
|
* @param {string} event
|
|
* @param {Hook} handler - this can be async or sync
|
|
* @returns {void}
|
|
*/
|
|
addHook(event, handler) {
|
|
this.onHookEntry({ event, handler });
|
|
}
|
|
/**
|
|
* Adds a handler function for a specific event
|
|
* @param {Array<HookEntry>} hooks
|
|
* @returns {void}
|
|
*/
|
|
onHooks(hooks) {
|
|
for (const hook of hooks) {
|
|
this.onHook(hook.event, hook.handler);
|
|
}
|
|
}
|
|
/**
|
|
* Adds a handler function for a specific event that runs before all other handlers
|
|
* @param {string} event
|
|
* @param {Hook} handler - this can be async or sync
|
|
* @returns {void}
|
|
*/
|
|
prependHook(event, handler) {
|
|
this.validateHookName(event);
|
|
if (!this.checkDeprecatedHook(event)) {
|
|
return;
|
|
}
|
|
const eventHandlers = this._hooks.get(event);
|
|
if (eventHandlers) {
|
|
eventHandlers.unshift(handler);
|
|
} else {
|
|
this._hooks.set(event, [handler]);
|
|
}
|
|
}
|
|
/**
|
|
* Adds a handler that only executes once for a specific event before all other handlers
|
|
* @param event
|
|
* @param handler
|
|
*/
|
|
prependOnceHook(event, handler) {
|
|
this.validateHookName(event);
|
|
if (!this.checkDeprecatedHook(event)) {
|
|
return;
|
|
}
|
|
const hook = async (...arguments_) => {
|
|
this.removeHook(event, hook);
|
|
return handler(...arguments_);
|
|
};
|
|
this.prependHook(event, hook);
|
|
}
|
|
/**
|
|
* Adds a handler that only executes once for a specific event
|
|
* @param event
|
|
* @param handler
|
|
*/
|
|
onceHook(event, handler) {
|
|
this.validateHookName(event);
|
|
if (!this.checkDeprecatedHook(event)) {
|
|
return;
|
|
}
|
|
const hook = async (...arguments_) => {
|
|
this.removeHook(event, hook);
|
|
return handler(...arguments_);
|
|
};
|
|
this.onHook(event, hook);
|
|
}
|
|
/**
|
|
* Removes a handler function for a specific event
|
|
* @param {string} event
|
|
* @param {Hook} handler
|
|
* @returns {void}
|
|
*/
|
|
removeHook(event, handler) {
|
|
this.validateHookName(event);
|
|
if (!this.checkDeprecatedHook(event)) {
|
|
return;
|
|
}
|
|
const eventHandlers = this._hooks.get(event);
|
|
if (eventHandlers) {
|
|
const index = eventHandlers.indexOf(handler);
|
|
if (index !== -1) {
|
|
eventHandlers.splice(index, 1);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Removes all handlers for a specific event
|
|
* @param {Array<HookEntry>} hooks
|
|
* @returns {void}
|
|
*/
|
|
removeHooks(hooks) {
|
|
for (const hook of hooks) {
|
|
this.removeHook(hook.event, hook.handler);
|
|
}
|
|
}
|
|
/**
|
|
* Calls all handlers for a specific event
|
|
* @param {string} event
|
|
* @param {T[]} arguments_
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async hook(event, ...arguments_) {
|
|
this.validateHookName(event);
|
|
if (!this.checkDeprecatedHook(event)) {
|
|
return;
|
|
}
|
|
const eventHandlers = this._hooks.get(event);
|
|
if (eventHandlers) {
|
|
for (const handler of eventHandlers) {
|
|
try {
|
|
await handler(...arguments_);
|
|
} catch (error) {
|
|
const message = `${event}: ${error.message}`;
|
|
this.emit("error", new Error(message));
|
|
if (this._throwOnHookError) {
|
|
throw new Error(message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Calls all synchronous handlers for a specific event.
|
|
* Async handlers (declared with `async` keyword) are silently skipped.
|
|
*
|
|
* Note: The `hook` method is preferred as it executes both sync and async functions.
|
|
* Use `hookSync` only when you specifically need synchronous execution.
|
|
* @param {string} event
|
|
* @param {T[]} arguments_
|
|
* @returns {void}
|
|
*/
|
|
hookSync(event, ...arguments_) {
|
|
this.validateHookName(event);
|
|
if (!this.checkDeprecatedHook(event)) {
|
|
return;
|
|
}
|
|
const eventHandlers = this._hooks.get(event);
|
|
if (eventHandlers) {
|
|
for (const handler of eventHandlers) {
|
|
if (handler.constructor.name === "AsyncFunction") {
|
|
continue;
|
|
}
|
|
try {
|
|
handler(...arguments_);
|
|
} catch (error) {
|
|
const message = `${event}: ${error.message}`;
|
|
this.emit("error", new Error(message));
|
|
if (this._throwOnHookError) {
|
|
throw new Error(message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Prepends the word `before` to your hook. Example is event is `test`, the before hook is `before:test`.
|
|
* @param {string} event - The event name
|
|
* @param {T[]} arguments_ - The arguments to pass to the hook
|
|
*/
|
|
async beforeHook(event, ...arguments_) {
|
|
await this.hook(`before:${event}`, ...arguments_);
|
|
}
|
|
/**
|
|
* Prepends the word `after` to your hook. Example is event is `test`, the after hook is `after:test`.
|
|
* @param {string} event - The event name
|
|
* @param {T[]} arguments_ - The arguments to pass to the hook
|
|
*/
|
|
async afterHook(event, ...arguments_) {
|
|
await this.hook(`after:${event}`, ...arguments_);
|
|
}
|
|
/**
|
|
* Calls all handlers for a specific event. This is an alias for `hook` and is provided for
|
|
* compatibility with other libraries that use the `callHook` method.
|
|
* @param {string} event
|
|
* @param {T[]} arguments_
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async callHook(event, ...arguments_) {
|
|
await this.hook(event, ...arguments_);
|
|
}
|
|
/**
|
|
* Gets all hooks for a specific event
|
|
* @param {string} event
|
|
* @returns {Hook[]}
|
|
*/
|
|
getHooks(event) {
|
|
this.validateHookName(event);
|
|
if (!this.checkDeprecatedHook(event)) {
|
|
return void 0;
|
|
}
|
|
return this._hooks.get(event);
|
|
}
|
|
/**
|
|
* Removes all hooks
|
|
* @returns {void}
|
|
*/
|
|
clearHooks() {
|
|
this._hooks.clear();
|
|
}
|
|
};
|
|
export {
|
|
Eventified,
|
|
Hookified
|
|
};
|
|
/* v8 ignore next -- @preserve */
|
|
//# sourceMappingURL=index.js.map
|