Merge pull request #26 from cb1kenobi/nested

Support nested linked emitters

Author: cb1kenobi

CHANGELOG.md

@@ -1,3 +1,8 @@
+# 4.1.2 (Feb 23, 2021)
+
+ * fix: Support nested linked emitters. ([#25](https://github.com/cb1kenobi/hook-emitter/issues/25))
+ * chore: Updated dependencies.
+
 # 4.1.1 (Nov 20, 2020)
 
  * fix: `emit()` should not throw on error, but rather return a rejected promise.

gulpfile.js

@@ -131,7 +131,7 @@ async function runTests(cover) {
 	args.push(path.join(mocha, 'bin', 'mocha'));
 
 	// add --inspect
-	if (process.argv.indexOf('--inspect') !== -1 || process.argv.indexOf('--inspect-brk') !== -1) {
+	if (process.argv.indexOf('--debug') !== -1 || process.argv.indexOf('--inspect') !== -1 || process.argv.indexOf('--inspect-brk') !== -1) {
 		args.push('--inspect-brk');
 	}
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hook-emitter",
-  "version": "4.1.1",
+  "version": "4.1.2",
   "description": "Event emitter with support for asynchronous handlers and a sweet function hook mechanism.",
   "main": "./dist/index.js",
   "author": "Chris Barber <chris@cb1inc.com> (https://github.com/cb1kenobi)",
@@ -28,34 +28,34 @@
     "source-map-support": "^0.5.19"
   },
   "devDependencies": {
-    "@babel/core": "^7.12.3",
-    "@babel/plugin-transform-modules-commonjs": "^7.12.1",
-    "@babel/register": "^7.12.1",
+    "@babel/core": "^7.13.1",
+    "@babel/plugin-transform-modules-commonjs": "^7.13.0",
+    "@babel/register": "^7.13.0",
     "ansi-colors": "^4.1.1",
     "babel-eslint": "^10.1.0",
-    "babel-loader": "^8.2.1",
+    "babel-loader": "^8.2.2",
     "babel-plugin-istanbul": "^6.0.0",
-    "chai": "^4.2.0",
+    "chai": "^4.3.0",
     "chai-as-promised": "^7.1.1",
     "coveralls": "^3.1.0",
     "esdoc": "^1.1.0",
     "esdoc-ecmascript-proposal-plugin": "^1.0.0",
     "esdoc-standard-plugin": "^1.0.0",
-    "eslint": "^7.13.0",
+    "eslint": "^7.20.0",
     "eslint-plugin-chai-expect": "^2.2.0",
     "eslint-plugin-mocha": "^8.0.0",
-    "eslint-plugin-promise": "^4.2.1",
+    "eslint-plugin-promise": "^4.3.1",
     "eslint-plugin-security": "^1.4.0",
     "fancy-log": "^1.3.3",
-    "fs-extra": "^9.0.1",
+    "fs-extra": "^9.1.0",
     "gulp": "^4.0.2",
     "gulp-babel": "^8.0.0",
     "gulp-debug": "^4.0.0",
     "gulp-eslint": "^6.0.0",
-    "gulp-load-plugins": "^2.0.5",
+    "gulp-load-plugins": "^2.0.6",
     "gulp-plumber": "^1.2.1",
     "gulp-sourcemaps": "^3.0.0",
-    "mocha": "^8.2.1",
+    "mocha": "^8.3.0",
     "nyc": "^15.1.0"
   },
   "homepage": "https://github.com/cb1kenobi/hook-emitter",

src/index.js

@@ -192,24 +192,31 @@ export class HookEmitter {
 			// listener in the chain
 			transform = (result, payload) => ({
 				type: payload.type,
-				args: result || payload.args
+				args: result !== undefined ? result : payload.args
 			});
 		}
 
 		// create the function that fetches the events since the list of
 		// listeners may change before the hook is called
 		const getListeners = () => {
-			const listeners = this._events.get(type) || [];
+			let listeners = this._events.get(type) || [];
 			if (!Array.isArray(listeners)) {
 				throw new TypeError('Expected listeners to be an array.');
 			}
 
-			const linkedListeners = this._links.map(link => {
-				return link.emitter.events.get((link.prefix || '') + type) || [];
-			});
+			// clone the listeners
+			listeners = [ ...listeners ];
+
+			for (const link of this._links) {
+				listeners.push({
+					listener: link.emitter.compose({
+						type: (link.prefix || '') + type
+					}),
+					priority: 0
+				});
+			}
 
 			return listeners
-				.concat.apply(listeners, linkedListeners)
 				.sort((a, b) => b.priority - a.priority)
 				.map(p => {
 					if (typeof p.listener !== 'function') {
@@ -255,7 +262,7 @@ export class HookEmitter {
 						// if somebody mixes paradigms and calls next().then(),
 						// at least their function will wait for the next listener
 						return dispatch(result || payload, i + 1)
-							.then(result => (innerResult = result || payload))
+							.then(result => (innerResult = result !== undefined ? result : payload))
 							.catch(reject);
 					} ];
 
@@ -269,7 +276,7 @@ export class HookEmitter {
 					if (result instanceof Promise) {
 						return result
 							.then(result => {
-								result = transform(fired && innerResult || result, payload);
+								result = transform(fired && innerResult !== undefined ? innerResult : result, payload);
 								return fired ? result : dispatch(result, i + 1);
 							})
 							.then(resolve)
@@ -345,7 +352,7 @@ export class HookEmitter {
 					this.result = await this.fn.apply(this.ctx, this.args);
 					return this;
 				},
-				transform: (result, data) => result || data
+				transform: (result, data) => result !== undefined ? result : data
 			});
 
 			return chain.apply(data, data.args).then(data => data.result);

test/.eslintrc

@@ -13,6 +13,7 @@
         "sinon": false
     },
     "rules": {
+        "no-debugger": "warn",
         "no-unused-vars": 0
     }
 }

test/test-hookemitter.js

@@ -1294,4 +1294,125 @@ describe('link', () => {
 			emitter.unlink('foo');
 		}).to.throw('Expected argument to be a HookEmitter.');
 	});
+
+	it('should link nested emitted events', async () => {
+		let aCount = 0;
+		let bCount = 0;
+		let cCount = 0;
+
+		const a = new HookEmitter().on('foo', () => aCount++);
+		const b = new HookEmitter().on('foo', () => bCount++);
+		const c = new HookEmitter().on('foo', () => cCount++);
+
+		await a.emit('foo');
+		expect(aCount).to.equal(1);
+		expect(bCount).to.equal(0);
+		expect(cCount).to.equal(0);
+
+		a.link(b);
+
+		await a.emit('foo');
+		expect(aCount).to.equal(2);
+		expect(bCount).to.equal(1);
+		expect(cCount).to.equal(0);
+
+		await b.emit('foo');
+		expect(aCount).to.equal(2);
+		expect(bCount).to.equal(2);
+		expect(cCount).to.equal(0);
+
+		b.link(c);
+
+		await a.emit('foo');
+		expect(aCount).to.equal(3);
+		expect(bCount).to.equal(3);
+		expect(cCount).to.equal(1);
+
+		await b.emit('foo');
+		expect(aCount).to.equal(3);
+		expect(bCount).to.equal(4);
+		expect(cCount).to.equal(2);
+	});
+
+	it('should link nested emitted hooks', async () => {
+		let aCount = 0;
+		let bCount = 0;
+		let cCount = 0;
+
+		let ahCount = 0;
+		let bhCount = 0;
+		let chCount = 0;
+
+		const a = new HookEmitter().on('foo', () => aCount++);
+		const b = new HookEmitter().on('foo', () => bCount++);
+		const c = new HookEmitter().on('foo', () => cCount++);
+
+		a.name = 'a';
+		b.name = 'b';
+		c.name = 'c';
+
+		const afn = a.hook('foo', () => ahCount++);
+		const bfn = b.hook('foo', () => bhCount++);
+		const cfn = c.hook('foo', () => chCount++);
+
+		await afn();
+		expect(ahCount).to.equal(1);
+		expect(bhCount).to.equal(0);
+		expect(chCount).to.equal(0);
+		expect(aCount).to.equal(1);
+		expect(bCount).to.equal(0);
+		expect(cCount).to.equal(0);
+
+		await bfn();
+		expect(ahCount).to.equal(1);
+		expect(bhCount).to.equal(1);
+		expect(chCount).to.equal(0);
+		expect(aCount).to.equal(1);
+		expect(bCount).to.equal(1);
+		expect(cCount).to.equal(0);
+
+		a.link(b);
+
+		await afn();
+		expect(ahCount).to.equal(2);
+		expect(bhCount).to.equal(1);
+		expect(chCount).to.equal(0);
+		expect(aCount).to.equal(2);
+		expect(bCount).to.equal(2);
+		expect(cCount).to.equal(0);
+
+		await bfn();
+		expect(ahCount).to.equal(2);
+		expect(bhCount).to.equal(2);
+		expect(chCount).to.equal(0);
+		expect(aCount).to.equal(2);
+		expect(bCount).to.equal(3);
+		expect(cCount).to.equal(0);
+
+		b.link(c);
+
+		await afn();
+		expect(ahCount).to.equal(3);
+		expect(bhCount).to.equal(2);
+		expect(chCount).to.equal(0);
+		expect(aCount).to.equal(3);
+		expect(bCount).to.equal(4);
+		expect(cCount).to.equal(1);
+
+		await bfn();
+		expect(ahCount).to.equal(3);
+		expect(bhCount).to.equal(3);
+		expect(chCount).to.equal(0);
+		expect(aCount).to.equal(3);
+		expect(bCount).to.equal(5);
+		expect(cCount).to.equal(2);
+
+		await cfn();
+		expect(ahCount).to.equal(3);
+		expect(bhCount).to.equal(3);
+		expect(chCount).to.equal(1);
+		expect(aCount).to.equal(3);
+		expect(bCount).to.equal(5);
+		expect(cCount).to.equal(3);
+	});
 });