feat: allow unregistering hooks

README.md

@@ -14,13 +14,13 @@
 
 ## Table of Contents
 
-- [About](#About)
+- [About](#about)
   - [Features](#Features)
-- [Installation](#Install)
-- [Usage](#Usage)
+- [Installation](#install)
+- [Usage](#usage)
   - [As a library author](#As-a-library-author)
   - [As a plugin author](#As-a-plugin-author)
-- [Used by](#Used-by)
+- [Used by](#used-by)
 - [Development / Contributing](#Development-Contributing)
 
 ## About
@@ -150,6 +150,35 @@ const { data } = await hooks.call('before:write', {
 });
 ```
 
+#### 4. Unregister hooks
+
+You can unregister hooks by:
+
+##### a) Calling the returned unregister function
+
+```js
+const unregister = hooks.register('before:write', myHookFunction);
+unregister();
+
+// for registerMany
+const unregisterMany = hooks.registerMany({
+	'before:write': myHookFunction,
+});
+unregisterMany();
+```
+
+##### b) Calling `hooks.unregister`
+
+```js
+hooks.register('before:write', myHookFunction);
+
+// unregister a specific callback for the 'before:write' hook
+hooks.unregister('before:write', myHookFunction);
+
+// unregister all callbacks for the 'before:write' hook
+hooks.unregister('before:write');
+```
+
 ### As plugin author
 
 #### Create a plugin

src/hooks.test.ts

@@ -115,3 +115,45 @@ test('allow asynchronous functions as middleware', (done) => {
 	});
 	hooks.call('test:hook');
 });
+
+it('should unregister a specific hook', async () => {
+	const hooks = createHooks<{
+		'test:hook': Hook<number, void>;
+	}>();
+
+	hooks.register('test:hook', (value) => {
+		return value * 2;
+	});
+	const unregisterTestHook2 = hooks.register('test:hook', (value) => {
+		return value * 3;
+	});
+
+	let result = await hooks.call('test:hook', { args: 1 });
+	expect(result).toEqual(6);
+
+	// Unregister testHook2 and call the hooks again
+	unregisterTestHook2();
+	result = await hooks.call('test:hook', { args: 1 });
+	expect(result).toEqual(2);
+});
+
+it('should unregister all hooks for a given name', async () => {
+	const hooks = createHooks<{
+		'test:hook': Hook<number, void>;
+	}>();
+
+	hooks.register('test:hook', (value) => {
+		return value * 2;
+	});
+	hooks.register('test:hook', (value) => {
+		return value * 3;
+	});
+
+	let result = await hooks.call('test:hook', { args: 1 });
+	expect(result).toEqual(6);
+
+	// Unregister all hooks for 'test:hook' and call the hooks again
+	hooks.unregister('test:hook');
+	result = await hooks.call('test:hook', { args: 1 });
+	expect(result).toEqual(1);
+});

src/index.ts

@@ -95,6 +95,17 @@ export function createHooks<T extends Hooks>() {
 	function register(name: K, hook: T[K]) {
 		if (!hooks[name]) hooks[name] = [];
 		hooks[name]?.push(hook);
+
+		return () => unregister(name, hook);
+	}
+
+	function unregister(name: K, hook?: T[K]) {
+		if (!hooks[name]) return;
+		if (hook) {
+			hooks[name] = hooks[name]?.filter((h) => h !== hook);
+		} else {
+			hooks[name] = undefined;
+		}
 	}
 
 	/**
@@ -106,12 +117,19 @@ export function createHooks<T extends Hooks>() {
 		Object.entries(hooks).forEach(([hookName, hook]) => {
 			register(hookName, hook);
 		});
+
+		return () => {
+			Object.entries(hooks).forEach(([hookName, hook]) => {
+				unregister(hookName, hook);
+			});
+		};
 	}
 
 	return {
 		call,
 		wrap,
 		register,
+		unregister,
 		registerMany,
 	};
 }