pax_global_header00006660000000000000000000000064137216737440014530gustar00rootroot0000000000000052 comment=00ac01a329b7f2fb29058b6a3aff6850ac304f12 eventemitter3-4.0.7/000077500000000000000000000000001372167374400143365ustar00rootroot00000000000000eventemitter3-4.0.7/.gitignore000066400000000000000000000001261372167374400163250ustar00rootroot00000000000000node_modules/ .nyc_output/ components/ coverage/ build/ umd/ .tern-port npm-debug.log eventemitter3-4.0.7/.npmrc000066400000000000000000000000231372167374400154510ustar00rootroot00000000000000package-lock=false eventemitter3-4.0.7/.travis.yml000066400000000000000000000013561372167374400164540ustar00rootroot00000000000000language: node_js matrix: fast_finish: true include: - node_js: "14" env: SCRIPT=test - node_js: "12" env: SCRIPT=test - node_js: "10" env: SCRIPT=test - node_js: "12" env: - secure: TgXbhcemKQTLl5+OdTMZyn3yNFgn2qqwpt8LccI8KVGfCKRHnKLOUE1PYXQi9tPRS5N+ofzHKzMVh5/2bfm3hCsihH0n6ItoWLLyd5BjcBWTp862wG4Dvgqq7dVofnf4eSVk34VYtqaKfszypRQ8UGvj/X48j5ANElU7OP4iIPg= - SAUCE_USERNAME=eventemitter3 - SCRIPT=test-browser script: - "npm run ${SCRIPT}" after_success: - 'if [ "${SCRIPT}" == "test" ]; then npm i coveralls@3 && nyc report --reporter=text-lcov | coveralls; fi' notifications: irc: channels: - "irc.freenode.org#primus" on_success: change on_failure: change eventemitter3-4.0.7/LICENSE000066400000000000000000000020721372167374400153440ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2014 Arnout Kazemier Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. eventemitter3-4.0.7/README.md000066400000000000000000000070641372167374400156240ustar00rootroot00000000000000# EventEmitter3 [![Version npm](https://img.shields.io/npm/v/eventemitter3.svg?style=flat-square)](https://www.npmjs.com/package/eventemitter3)[![Build Status](https://img.shields.io/travis/primus/eventemitter3/master.svg?style=flat-square)](https://travis-ci.org/primus/eventemitter3)[![Dependencies](https://img.shields.io/david/primus/eventemitter3.svg?style=flat-square)](https://david-dm.org/primus/eventemitter3)[![Coverage Status](https://img.shields.io/coveralls/primus/eventemitter3/master.svg?style=flat-square)](https://coveralls.io/r/primus/eventemitter3?branch=master)[![IRC channel](https://img.shields.io/badge/IRC-irc.freenode.net%23primus-00a8ff.svg?style=flat-square)](https://webchat.freenode.net/?channels=primus) [![Sauce Test Status](https://saucelabs.com/browser-matrix/eventemitter3.svg)](https://saucelabs.com/u/eventemitter3) EventEmitter3 is a high performance EventEmitter. It has been micro-optimized for various of code paths making this, one of, if not the fastest EventEmitter available for Node.js and browsers. The module is API compatible with the EventEmitter that ships by default with Node.js but there are some slight differences: - Domain support has been removed. - We do not `throw` an error when you emit an `error` event and nobody is listening. - The `newListener` and `removeListener` events have been removed as they are useful only in some uncommon use-cases. - The `setMaxListeners`, `getMaxListeners`, `prependListener` and `prependOnceListener` methods are not available. - Support for custom context for events so there is no need to use `fn.bind`. - The `removeListener` method removes all matching listeners, not only the first. It's a drop in replacement for existing EventEmitters, but just faster. Free performance, who wouldn't want that? The EventEmitter is written in EcmaScript 3 so it will work in the oldest browsers and node versions that you need to support. ## Installation ```bash $ npm install --save eventemitter3 ``` ## CDN Recommended CDN: ```text https://unpkg.com/eventemitter3@latest/umd/eventemitter3.min.js ``` ## Usage After installation the only thing you need to do is require the module: ```js var EventEmitter = require('eventemitter3'); ``` And you're ready to create your own EventEmitter instances. For the API documentation, please follow the official Node.js documentation: http://nodejs.org/api/events.html ### Contextual emits We've upgraded the API of the `EventEmitter.on`, `EventEmitter.once` and `EventEmitter.removeListener` to accept an extra argument which is the `context` or `this` value that should be set for the emitted events. This means you no longer have the overhead of an event that required `fn.bind` in order to get a custom `this` value. ```js var EE = new EventEmitter() , context = { foo: 'bar' }; function emitted() { console.log(this === context); // true } EE.once('event-name', emitted, context); EE.on('another-event', emitted, context); EE.removeListener('another-event', emitted, context); ``` ### Tests and benchmarks This module is well tested. You can run: - `npm test` to run the tests under Node.js. - `npm run test-browser` to run the tests in real browsers via Sauce Labs. We also have a set of benchmarks to compare EventEmitter3 with some available alternatives. To run the benchmarks run `npm run benchmark`. Tests and benchmarks are not included in the npm package. If you want to play with them you have to clone the GitHub repository. Note that you will have to run an additional `npm i` in the benchmarks folder before `npm run benchmark`. ## License [MIT](LICENSE) eventemitter3-4.0.7/benchmarks/000077500000000000000000000000001372167374400164535ustar00rootroot00000000000000eventemitter3-4.0.7/benchmarks/README.md000066400000000000000000000110321372167374400177270ustar00rootroot00000000000000Starting benchmark listeners.js ``` EventEmitter1 x 7,572,173 ops/sec ±0.93% (92 runs sampled) EventEmitter3@0.1.6 x 7,990,937 ops/sec ±0.31% (93 runs sampled) EventEmitter3(master) x 8,140,661 ops/sec ±0.44% (91 runs sampled) fastemitter x 5,554,014 ops/sec ±0.37% (88 runs sampled) Fastest is EventEmitter3(master) ``` Starting benchmark init.js ``` EventEmitter1 x 15,101,015 ops/sec ±1.66% (89 runs sampled) EventEmitter2 x 23,365,046 ops/sec ±0.50% (90 runs sampled) EventEmitter3@0.1.6 x 32,657,186 ops/sec ±0.61% (88 runs sampled) EventEmitter3(master) x 28,325,527 ops/sec ±0.25% (95 runs sampled) Drip x 33,751,683 ops/sec ±1.31% (84 runs sampled) fastemitter x 11,738,645 ops/sec ±0.35% (86 runs sampled) event-emitter x 22,670,613 ops/sec ±0.23% (95 runs sampled) contra/emitter x 1,102,480 ops/sec ±0.43% (91 runs sampled) Fastest is Drip ``` Starting benchmark remove-emit.js ``` EventEmitter1 x 6,175,136 ops/sec ±0.44% (90 runs sampled) EventEmitter2 x 5,767,426 ops/sec ±1.08% (87 runs sampled) EventEmitter3@0.1.6 x 10,269,081 ops/sec ±0.91% (88 runs sampled) EventEmitter3(master) x 11,549,113 ops/sec ±0.67% (88 runs sampled) Drip x 5,795,926 ops/sec ±1.20% (88 runs sampled) event-emitter x 4,515,241 ops/sec ±0.47% (90 runs sampled) contra/emitter x 403,089 ops/sec ±0.79% (90 runs sampled) Fastest is EventEmitter3(master) ``` Starting benchmark emit-multiple-listeners.js ``` EventEmitter1 x 2,507,915 ops/sec ±0.53% (93 runs sampled) EventEmitter2 x 1,126,907 ops/sec ±0.29% (94 runs sampled) EventEmitter3@0.1.6 x 2,377,802 ops/sec ±0.92% (89 runs sampled) EventEmitter3(master) x 2,904,038 ops/sec ±1.06% (94 runs sampled) fastemitter x 2,804,437 ops/sec ±0.30% (92 runs sampled) event-emitter x 944,055 ops/sec ±0.21% (94 runs sampled) contra/emitter x 363,577 ops/sec ±0.46% (90 runs sampled) Fastest is EventEmitter3(master) ``` Starting benchmark context.js ``` EventEmitter1 x 5,944,004 ops/sec ±0.40% (92 runs sampled) EventEmitter2 x 6,142,119 ops/sec ±0.33% (88 runs sampled) EventEmitter3@0.1.6 x 10,021,281 ops/sec ±0.34% (90 runs sampled) EventEmitter3(master) x 12,449,276 ops/sec ±0.85% (87 runs sampled) Drip x 6,112,535 ops/sec ±1.07% (94 runs sampled) fastemitter x 5,351,583 ops/sec ±0.33% (91 runs sampled) event-emitter x 4,664,745 ops/sec ±0.89% (91 runs sampled) contra/emitter x 432,819 ops/sec ±0.45% (93 runs sampled) Fastest is EventEmitter3(master) ``` Starting benchmark once.js ``` EventEmitter1 x 3,570,512 ops/sec ±0.43% (90 runs sampled) EventEmitter2 x 2,375,433 ops/sec ±1.28% (88 runs sampled) EventEmitter3@0.1.6 x 6,800,263 ops/sec ±0.62% (89 runs sampled) EventEmitter3(master) x 11,971,608 ops/sec ±1.55% (86 runs sampled) Drip x 6,555,088 ops/sec ±0.80% (87 runs sampled) fastemitter x 6,320,868 ops/sec ±0.41% (87 runs sampled) event-emitter x 2,251,961 ops/sec ±0.26% (90 runs sampled) contra/emitter x 1,373,169 ops/sec ±0.36% (94 runs sampled) Fastest is EventEmitter3(master) ``` Starting benchmark hundreds.js ``` EventEmitter1 x 376,475 ops/sec ±0.32% (89 runs sampled) EventEmitter2 x 163,023 ops/sec ±0.30% (94 runs sampled) EventEmitter3@0.1.6 x 342,899 ops/sec ±0.32% (93 runs sampled) EventEmitter3(master) x 343,984 ops/sec ±0.31% (93 runs sampled) Drip x 323,076 ops/sec ±0.29% (90 runs sampled) fastemitter x 435,626 ops/sec ±0.32% (90 runs sampled) event-emitter x 169,640 ops/sec ±0.40% (90 runs sampled) contra/emitter x 94,023 ops/sec ±0.45% (90 runs sampled) Fastest is fastemitter ``` Starting benchmark emit.js ``` EventEmitter1 x 6,174,178 ops/sec ±0.28% (93 runs sampled) EventEmitter2 x 6,334,281 ops/sec ±0.72% (94 runs sampled) EventEmitter3@0.1.6 x 10,379,672 ops/sec ±0.38% (90 runs sampled) EventEmitter3(master) x 12,147,337 ops/sec ±0.54% (84 runs sampled) Drip x 6,290,746 ops/sec ±0.30% (93 runs sampled) fastemitter x 5,301,900 ops/sec ±0.72% (92 runs sampled) event-emitter x 4,887,035 ops/sec ±0.43% (89 runs sampled) contra/emitter x 427,013 ops/sec ±0.76% (93 runs sampled) Fastest is EventEmitter3(master) ``` Starting benchmark add-remove.js ``` EventEmitter1 x 4,737,119 ops/sec ±0.32% (91 runs sampled) EventEmitter2 x 4,775,450 ops/sec ±0.56% (88 runs sampled) EventEmitter3@0.1.6 x 7,598,665 ops/sec ±0.52% (91 runs sampled) EventEmitter3(master) x 18,016,994 ops/sec ±0.43% (87 runs sampled) Drip x 32,917,832 ops/sec ±1.55% (82 runs sampled) fastemitter x 15,904,236 ops/sec ±0.40% (88 runs sampled) event-emitter x 3,809,036 ops/sec ±0.75% (93 runs sampled) contra/emitter x 6,141,581 ops/sec ±0.33% (93 runs sampled) Fastest is Drip ``` eventemitter3-4.0.7/benchmarks/package.json000066400000000000000000000007751372167374400207520ustar00rootroot00000000000000{ "name": "benchmarks", "version": "0.0.0", "description": "eventemitter3 benchmarks", "main": "index.js", "scripts": { "benchmark": "find run -name '*.js' -exec ./start.sh {} \\;" }, "repository": "primus/eventemitter3", "author": "Arnout Kazemier", "license": "MIT", "dependencies": { "benchmark": "2.1.x", "contra": "latest", "drip": "latest", "event-emitter": "latest", "eventemitter2": "latest", "eventemitter3": "0.1.6", "fastemitter": "latest" } } eventemitter3-4.0.7/benchmarks/run/000077500000000000000000000000001372167374400172575ustar00rootroot00000000000000eventemitter3-4.0.7/benchmarks/run/add-remove.js000066400000000000000000000031611372167374400216410ustar00rootroot00000000000000'use strict'; var benchmark = require('benchmark'); var EventEmitter2 = require('eventemitter2').EventEmitter2 , EventEmitter1 = require('events').EventEmitter , EventEmitter3 = require('eventemitter3') , Drip = require('drip').EventEmitter , CE = require('contra/emitter') , EE = require('event-emitter') , FE = require('fastemitter') , Master = require('../../'); function handle() { if (arguments.length > 100) console.log('damn'); } var ee1 = new EventEmitter1() , ee2 = new EventEmitter2() , ee3 = new EventEmitter3() , master = new Master() , drip = new Drip() , fe = new FE() , ce = CE() , ee = EE(); ( new benchmark.Suite() ).add('EventEmitter1', function() { ee1.on('foo', handle); ee1.removeListener('foo', handle); }).add('EventEmitter2', function() { ee2.on('foo', handle); ee2.removeListener('foo', handle); }).add('EventEmitter3@0.1.6', function() { ee3.on('foo', handle); ee3.removeListener('foo', handle); }).add('EventEmitter3(master)', function() { master.on('foo', handle); master.removeListener('foo', handle); }).add('Drip', function() { drip.on('foo', handle); drip.removeListener('foo', handle); }).add('fastemitter', function() { fe.on('foo', handle); fe.removeListener('foo', handle); }).add('event-emitter', function() { ee.on('foo', handle); ee.off('foo', handle); }).add('contra/emitter', function() { ce.on('foo', handle); ce.off('foo', handle); }).on('cycle', function cycle(e) { console.log(e.target.toString()); }).on('complete', function completed() { console.log('Fastest is %s', this.filter('fastest').map('name')); }).run({ async: true }); eventemitter3-4.0.7/benchmarks/run/context.js000066400000000000000000000045541372167374400213110ustar00rootroot00000000000000'use strict'; var benchmark = require('benchmark'); var EventEmitter2 = require('eventemitter2').EventEmitter2 , EventEmitter1 = require('events').EventEmitter , EventEmitter3 = require('eventemitter3') , Drip = require('drip').EventEmitter , CE = require('contra/emitter') , EE = require('event-emitter') , FE = require('fastemitter') , Master = require('../../'); var ctx = { foo: 'bar' }; function handle() { if (arguments.length > 100) console.log('damn'); } var ee1 = new EventEmitter1() , ee2 = new EventEmitter2() , ee3 = new EventEmitter3() , master = new Master() , drip = new Drip() , fe = new FE() , ce = CE() , ee = EE(); ee3.on('foo', handle, ctx); ee2.on('foo', handle.bind(ctx)); ee1.on('foo', handle.bind(ctx)); drip.on('foo', handle.bind(ctx)); master.on('foo', handle, ctx); ee.on('foo', handle.bind(ctx)); fe.on('foo', handle.bind(ctx)); ce.on('foo', handle.bind(ctx)); ( new benchmark.Suite() ).add('EventEmitter1', function() { ee1.emit('foo'); ee1.emit('foo', 'bar'); ee1.emit('foo', 'bar', 'baz'); ee1.emit('foo', 'bar', 'baz', 'boom'); }).add('EventEmitter2', function() { ee2.emit('foo'); ee2.emit('foo', 'bar'); ee2.emit('foo', 'bar', 'baz'); ee2.emit('foo', 'bar', 'baz', 'boom'); }).add('EventEmitter3@0.1.6', function() { ee3.emit('foo'); ee3.emit('foo', 'bar'); ee3.emit('foo', 'bar', 'baz'); ee3.emit('foo', 'bar', 'baz', 'boom'); }).add('EventEmitter3(master)', function() { master.emit('foo'); master.emit('foo', 'bar'); master.emit('foo', 'bar', 'baz'); master.emit('foo', 'bar', 'baz', 'boom'); }).add('Drip', function() { drip.emit('foo'); drip.emit('foo', 'bar'); drip.emit('foo', 'bar', 'baz'); drip.emit('foo', 'bar', 'baz', 'boom'); }).add('fastemitter', function() { fe.emit('foo'); fe.emit('foo', 'bar'); fe.emit('foo', 'bar', 'baz'); fe.emit('foo', 'bar', 'baz', 'boom'); }).add('event-emitter', function() { ee.emit('foo'); ee.emit('foo', 'bar'); ee.emit('foo', 'bar', 'baz'); ee.emit('foo', 'bar', 'baz', 'boom'); }).add('contra/emitter', function() { ce.emit('foo'); ce.emit('foo', 'bar'); ce.emit('foo', 'bar', 'baz'); ce.emit('foo', 'bar', 'baz', 'boom'); }).on('cycle', function cycle(e) { console.log(e.target.toString()); }).on('complete', function completed() { console.log('Fastest is %s', this.filter('fastest').map('name')); }).run({ async: true }); eventemitter3-4.0.7/benchmarks/run/emit-multiple-listeners.js000066400000000000000000000047661372167374400244270ustar00rootroot00000000000000'use strict'; var benchmark = require('benchmark'); var EventEmitter2 = require('eventemitter2').EventEmitter2 , EventEmitter1 = require('events').EventEmitter , EventEmitter3 = require('eventemitter3') , CE = require('contra/emitter') , EE = require('event-emitter') , FE = require('fastemitter') , Master = require('../../'); function foo() { if (arguments.length > 100) console.log('damn'); return 1; } function bar() { if (arguments.length > 100) console.log('damn'); return false; } function baz() { if (arguments.length > 100) console.log('damn'); return true; } var ee1 = new EventEmitter1() , ee2 = new EventEmitter2() , ee3 = new EventEmitter3() , master = new Master() , fe = new FE() , ce = CE() , ee = EE(); ce.on('foo', foo).on('foo', bar).on('foo', baz); ee.on('foo', foo).on('foo', bar).on('foo', baz); fe.on('foo', foo).on('foo', bar).on('foo', baz); ee3.on('foo', foo).on('foo', bar).on('foo', baz); ee2.on('foo', foo).on('foo', bar).on('foo', baz); ee1.on('foo', foo).on('foo', bar).on('foo', baz); master.on('foo', foo).on('foo', bar).on('foo', baz); // // Drip is omitted as it throws an error. // Ref: https://github.com/qualiancy/drip/pull/4 // ( new benchmark.Suite() ).add('EventEmitter1', function() { ee1.emit('foo'); ee1.emit('foo', 'bar'); ee1.emit('foo', 'bar', 'baz'); ee1.emit('foo', 'bar', 'baz', 'boom'); }).add('EventEmitter2', function() { ee2.emit('foo'); ee2.emit('foo', 'bar'); ee2.emit('foo', 'bar', 'baz'); ee2.emit('foo', 'bar', 'baz', 'boom'); }).add('EventEmitter3@0.1.6', function() { ee3.emit('foo'); ee3.emit('foo', 'bar'); ee3.emit('foo', 'bar', 'baz'); ee3.emit('foo', 'bar', 'baz', 'boom'); }).add('EventEmitter3(master)', function() { master.emit('foo'); master.emit('foo', 'bar'); master.emit('foo', 'bar', 'baz'); master.emit('foo', 'bar', 'baz', 'boom'); }).add('fastemitter', function() { fe.emit('foo'); fe.emit('foo', 'bar'); fe.emit('foo', 'bar', 'baz'); fe.emit('foo', 'bar', 'baz', 'boom'); }).add('event-emitter', function() { ee.emit('foo'); ee.emit('foo', 'bar'); ee.emit('foo', 'bar', 'baz'); ee.emit('foo', 'bar', 'baz', 'boom'); }).add('contra/emitter', function() { ce.emit('foo'); ce.emit('foo', 'bar'); ce.emit('foo', 'bar', 'baz'); ce.emit('foo', 'bar', 'baz', 'boom'); }).on('cycle', function cycle(e) { console.log(e.target.toString()); }).on('complete', function completed() { console.log('Fastest is %s', this.filter('fastest').map('name')); }).run({ async: true }); eventemitter3-4.0.7/benchmarks/run/emit.js000066400000000000000000000044131372167374400205550ustar00rootroot00000000000000'use strict'; var benchmark = require('benchmark'); var EventEmitter2 = require('eventemitter2').EventEmitter2 , EventEmitter1 = require('events').EventEmitter , EventEmitter3 = require('eventemitter3') , Drip = require('drip').EventEmitter , CE = require('contra/emitter') , EE = require('event-emitter') , FE = require('fastemitter') , Master = require('../../'); function handle() { if (arguments.length > 100) console.log('damn'); } var ee1 = new EventEmitter1() , ee2 = new EventEmitter2() , ee3 = new EventEmitter3() , master = new Master() , drip = new Drip() , fe = new FE() , ce = CE() , ee = EE(); ee.on('foo', handle); fe.on('foo', handle); ee3.on('foo', handle); ee2.on('foo', handle); ee1.on('foo', handle); drip.on('foo', handle); master.on('foo', handle); ce.on('foo', handle); ( new benchmark.Suite() ).add('EventEmitter1', function() { ee1.emit('foo'); ee1.emit('foo', 'bar'); ee1.emit('foo', 'bar', 'baz'); ee1.emit('foo', 'bar', 'baz', 'boom'); }).add('EventEmitter2', function() { ee2.emit('foo'); ee2.emit('foo', 'bar'); ee2.emit('foo', 'bar', 'baz'); ee2.emit('foo', 'bar', 'baz', 'boom'); }).add('EventEmitter3@0.1.6', function() { ee3.emit('foo'); ee3.emit('foo', 'bar'); ee3.emit('foo', 'bar', 'baz'); ee3.emit('foo', 'bar', 'baz', 'boom'); }).add('EventEmitter3(master)', function() { master.emit('foo'); master.emit('foo', 'bar'); master.emit('foo', 'bar', 'baz'); master.emit('foo', 'bar', 'baz', 'boom'); }).add('Drip', function() { drip.emit('foo'); drip.emit('foo', 'bar'); drip.emit('foo', 'bar', 'baz'); drip.emit('foo', 'bar', 'baz', 'boom'); }).add('fastemitter', function() { fe.emit('foo'); fe.emit('foo', 'bar'); fe.emit('foo', 'bar', 'baz'); fe.emit('foo', 'bar', 'baz', 'boom'); }).add('event-emitter', function() { ee.emit('foo'); ee.emit('foo', 'bar'); ee.emit('foo', 'bar', 'baz'); ee.emit('foo', 'bar', 'baz', 'boom'); }).add('contra/emitter', function() { ce.emit('foo'); ce.emit('foo', 'bar'); ce.emit('foo', 'bar', 'baz'); ce.emit('foo', 'bar', 'baz', 'boom'); }).on('cycle', function cycle(e) { console.log(e.target.toString()); }).on('complete', function completed() { console.log('Fastest is %s', this.filter('fastest').map('name')); }).run({ async: true }); eventemitter3-4.0.7/benchmarks/run/hundreds.js000066400000000000000000000037111372167374400214330ustar00rootroot00000000000000'use strict'; var benchmark = require('benchmark'); var EventEmitter2 = require('eventemitter2').EventEmitter2 , EventEmitter1 = require('events').EventEmitter , EventEmitter3 = require('eventemitter3') , Drip = require('drip').EventEmitter , CE = require('contra/emitter') , EE = require('event-emitter') , FE = require('fastemitter') , Master = require('../../'); function foo() { if (arguments.length > 100) console.log('damn'); return 1; } var ee1 = new EventEmitter1() , ee2 = new EventEmitter2() , ee3 = new EventEmitter3() , master = new Master() , drip = new Drip() , fe = new FE() , ce = CE() , ee = EE() , j, i; for (i = 0; i < 10; i++) { for (j = 0; j < 10; j++) { ce.on('event:' + i, foo); ee.on('event:' + i, foo); fe.on('event:' + i, foo); ee1.on('event:' + i, foo); ee2.on('event:' + i, foo); ee3.on('event:' + i, foo); drip.on('event:' + i, foo); master.on('event:' + i, foo); } } ( new benchmark.Suite() ).add('EventEmitter1', function() { for (i = 0; i < 10; i++) { ee1.emit('event:' + i); } }).add('EventEmitter2', function() { for (i = 0; i < 10; i++) { ee2.emit('event:' + i); } }).add('EventEmitter3@0.1.6', function() { for (i = 0; i < 10; i++) { ee3.emit('event:' + i); } }).add('EventEmitter3(master)', function() { for (i = 0; i < 10; i++) { master.emit('event:' + i); } }).add('Drip', function() { for (i = 0; i < 10; i++) { drip.emit('event:' + i); } }).add('fastemitter', function() { for (i = 0; i < 10; i++) { fe.emit('event:' + i); } }).add('event-emitter', function() { for (i = 0; i < 10; i++) { ee.emit('event:' + i); } }).add('contra/emitter', function() { for (i = 0; i < 10; i++) { ce.emit('event:' + i); } }).on('cycle', function cycle(e) { console.log(e.target.toString()); }).on('complete', function completed() { console.log('Fastest is %s', this.filter('fastest').map('name')); }).run({ async: true }); eventemitter3-4.0.7/benchmarks/run/init.js000066400000000000000000000023111372167374400205550ustar00rootroot00000000000000'use strict'; var benchmark = require('benchmark'); var EventEmitter2 = require('eventemitter2').EventEmitter2 , EventEmitter1 = require('events').EventEmitter , EventEmitter3 = require('eventemitter3') , Drip = require('drip').EventEmitter , CE = require('contra/emitter') , EE = require('event-emitter') , FE = require('fastemitter') , Master = require('../../'); // // This is used to prevent the functions below from being transformed into // noops. // var emitter; ( new benchmark.Suite() ).add('EventEmitter1', function() { emitter = new EventEmitter1(); }).add('EventEmitter2', function() { emitter = new EventEmitter2(); }).add('EventEmitter3@0.1.6', function() { emitter = new EventEmitter3(); }).add('EventEmitter3(master)', function() { emitter = new Master(); }).add('Drip', function() { emitter = new Drip(); }).add('fastemitter', function() { emitter = new FE(); }).add('event-emitter', function() { emitter = EE(); }).add('contra/emitter', function() { emitter = CE(); }).on('cycle', function cycle(e) { console.log(e.target.toString()); }).on('complete', function completed() { console.log('Fastest is %s', this.filter('fastest').map('name')); }).run({ async: true }); eventemitter3-4.0.7/benchmarks/run/listeners.js000066400000000000000000000025351372167374400216320ustar00rootroot00000000000000'use strict'; var benchmark = require('benchmark'); var EventEmitter1 = require('events').EventEmitter , EventEmitter3 = require('eventemitter3') , FE = require('fastemitter') , Master = require('../../'); var MAX_LISTENERS = Math.pow(2, 32) - 1; function handle() { if (arguments.length > 100) console.log('damn'); } var ee1 = new EventEmitter1() , ee3 = new EventEmitter3() , master = new Master() , fe = new FE(); ee1.setMaxListeners(MAX_LISTENERS); fe.setMaxListeners(MAX_LISTENERS); for (var i = 0; i < 25; i++) { ee1.on('event', handle); ee3.on('event', handle); master.on('event', handle); fe.on('event', handle); } // // eventemitter2 doesn't correctly handle listeners as they can be removed by // doing `ee2.listeners('event').length = 0;`. Same counts for Drip. // // event-emitter and contra/emitter do not implement `listeners`. // ( new benchmark.Suite() ).add('EventEmitter1', function () { ee1.listeners('event'); }).add('EventEmitter3@0.1.6', function() { ee3.listeners('event'); }).add('EventEmitter3(master)', function() { master.listeners('event'); }).add('fastemitter', function() { fe.listeners('event'); }).on('cycle', function cycle(e) { console.log(e.target.toString()); }).on('complete', function completed() { console.log('Fastest is %s', this.filter('fastest').map('name')); }).run({ async: true }); eventemitter3-4.0.7/benchmarks/run/once.js000066400000000000000000000027161372167374400205470ustar00rootroot00000000000000'use strict'; var benchmark = require('benchmark'); var EventEmitter2 = require('eventemitter2').EventEmitter2 , EventEmitter1 = require('events').EventEmitter , EventEmitter3 = require('eventemitter3') , Drip = require('drip').EventEmitter , CE = require('contra/emitter') , EE = require('event-emitter') , FE = require('fastemitter') , Master = require('../../'); function handle() { if (arguments.length > 100) console.log('damn'); } var ee1 = new EventEmitter1() , ee2 = new EventEmitter2() , ee3 = new EventEmitter3() , master = new Master() , drip = new Drip() , fe = new FE() , ce = CE() , ee = EE(); ( new benchmark.Suite() ).add('EventEmitter1', function() { ee1.once('foo', handle).emit('foo'); }).add('EventEmitter2', function() { ee2.once('foo', handle).emit('foo'); }).add('EventEmitter3@0.1.6', function() { ee3.once('foo', handle).emit('foo'); }).add('EventEmitter3(master)', function() { master.once('foo', handle).emit('foo'); }).add('Drip', function() { drip.once('foo', handle).emit('foo'); }).add('fastemitter', function() { fe.once('foo', handle).emit('foo'); }).add('event-emitter', function() { ee.once('foo', handle).emit('foo'); }).add('contra/emitter', function() { ce.once('foo', handle).emit('foo'); }).on('cycle', function cycle(e) { console.log(e.target.toString()); }).on('complete', function completed() { console.log('Fastest is %s', this.filter('fastest').map('name')); }).run({ async: true }); eventemitter3-4.0.7/benchmarks/run/remove-emit.js000066400000000000000000000046221372167374400220520ustar00rootroot00000000000000'use strict'; var benchmark = require('benchmark'); var EventEmitter2 = require('eventemitter2').EventEmitter2 , EventEmitter1 = require('events').EventEmitter , EventEmitter3 = require('eventemitter3') , Drip = require('drip').EventEmitter , CE = require('contra/emitter') , EE = require('event-emitter') , Master = require('../../'); function handle() { if (arguments.length > 100) console.log('damn'); } var ee1 = new EventEmitter1() , ee2 = new EventEmitter2() , ee3 = new EventEmitter3() , master = new Master() , drip = new Drip() , ce = CE() , ee = EE(); [ee1, ee2, ee3, master, drip, ee, ce].forEach(function ohai(emitter) { emitter.on('foo', handle); // // We add and remove a listener to see if the event emitter implementation is // de-optimized because it deletes items from an object etc. // emitter.on('ohai', ohai); if (emitter.removeListener) emitter.removeListener('ohai', ohai); else if (emitter.off) emitter.off('ohai', ohai); else throw new Error('No proper remove implementation'); }); // // FastEmitter is omitted as it throws an error. // ( new benchmark.Suite() ).add('EventEmitter1', function() { ee1.emit('foo'); ee1.emit('foo', 'bar'); ee1.emit('foo', 'bar', 'baz'); ee1.emit('foo', 'bar', 'baz', 'boom'); }).add('EventEmitter2', function() { ee2.emit('foo'); ee2.emit('foo', 'bar'); ee2.emit('foo', 'bar', 'baz'); ee2.emit('foo', 'bar', 'baz', 'boom'); }).add('EventEmitter3@0.1.6', function() { ee3.emit('foo'); ee3.emit('foo', 'bar'); ee3.emit('foo', 'bar', 'baz'); ee3.emit('foo', 'bar', 'baz', 'boom'); }).add('EventEmitter3(master)', function() { master.emit('foo'); master.emit('foo', 'bar'); master.emit('foo', 'bar', 'baz'); master.emit('foo', 'bar', 'baz', 'boom'); }).add('Drip', function() { drip.emit('foo'); drip.emit('foo', 'bar'); drip.emit('foo', 'bar', 'baz'); drip.emit('foo', 'bar', 'baz', 'boom'); }).add('event-emitter', function() { ee.emit('foo'); ee.emit('foo', 'bar'); ee.emit('foo', 'bar', 'baz'); ee.emit('foo', 'bar', 'baz', 'boom'); }).add('contra/emitter', function() { ce.emit('foo'); ce.emit('foo', 'bar'); ce.emit('foo', 'bar', 'baz'); ce.emit('foo', 'bar', 'baz', 'boom'); }).on('cycle', function cycle(e) { console.log(e.target.toString()); }).on('complete', function completed() { console.log('Fastest is %s', this.filter('fastest').map('name')); }).run({ async: true }); eventemitter3-4.0.7/benchmarks/start.sh000077500000000000000000000002541372167374400201500ustar00rootroot00000000000000#!/usr/bin/env bash if [ $# -eq 0 ]; then echo "usage: $0 " exit 1 fi benchmark=$1 echo Starting benchmark "${benchmark##*/}" echo node "$benchmark" echo eventemitter3-4.0.7/benchmarks/template.js000066400000000000000000000006401372167374400206240ustar00rootroot00000000000000'use strict'; /** * Benchmark related modules. */ var benchmark = require('benchmark'); /** * Preparation code. */ ( new benchmark.Suite() ).add('', function() { }).add('', function() { }).on('cycle', function cycle(e) { console.log(e.target.toString()); }).on('complete', function completed() { console.log('Fastest is %s', this.filter('fastest').map('name')); }).run({ async: true }); eventemitter3-4.0.7/index.d.ts000066400000000000000000000066161372167374400162500ustar00rootroot00000000000000/** * Minimal `EventEmitter` interface that is molded against the Node.js * `EventEmitter` interface. */ declare class EventEmitter< EventTypes extends EventEmitter.ValidEventTypes = string | symbol, Context extends any = any > { static prefixed: string | boolean; /** * Return an array listing the events for which the emitter has registered * listeners. */ eventNames(): Array>; /** * Return the listeners registered for a given event. */ listeners>( event: T ): Array>; /** * Return the number of listeners listening to a given event. */ listenerCount(event: EventEmitter.EventNames): number; /** * Calls each of the listeners registered for a given event. */ emit>( event: T, ...args: EventEmitter.EventArgs ): boolean; /** * Add a listener for a given event. */ on>( event: T, fn: EventEmitter.EventListener, context?: Context ): this; addListener>( event: T, fn: EventEmitter.EventListener, context?: Context ): this; /** * Add a one-time listener for a given event. */ once>( event: T, fn: EventEmitter.EventListener, context?: Context ): this; /** * Remove the listeners of a given event. */ removeListener>( event: T, fn?: EventEmitter.EventListener, context?: Context, once?: boolean ): this; off>( event: T, fn?: EventEmitter.EventListener, context?: Context, once?: boolean ): this; /** * Remove all listeners, or those of the specified event. */ removeAllListeners(event?: EventEmitter.EventNames): this; } declare namespace EventEmitter { export interface ListenerFn { (...args: Args): void; } export interface EventEmitterStatic { new < EventTypes extends ValidEventTypes = string | symbol, Context = any >(): EventEmitter; } /** * `object` should be in either of the following forms: * ``` * interface EventTypes { * 'event-with-parameters': any[] * 'event-with-example-handler': (...args: any[]) => void * } * ``` */ export type ValidEventTypes = string | symbol | object; export type EventNames = T extends string | symbol ? T : keyof T; export type ArgumentMap = { [K in keyof T]: T[K] extends (...args: any[]) => void ? Parameters : T[K] extends any[] ? T[K] : any[]; }; export type EventListener< T extends ValidEventTypes, K extends EventNames > = T extends string | symbol ? (...args: any[]) => void : ( ...args: ArgumentMap>[Extract] ) => void; export type EventArgs< T extends ValidEventTypes, K extends EventNames > = Parameters>; export const EventEmitter: EventEmitterStatic; } export = EventEmitter; eventemitter3-4.0.7/index.js000066400000000000000000000216651372167374400160150ustar00rootroot00000000000000'use strict'; var has = Object.prototype.hasOwnProperty , prefix = '~'; /** * Constructor to create a storage for our `EE` objects. * An `Events` instance is a plain object whose properties are event names. * * @constructor * @private */ function Events() {} // // We try to not inherit from `Object.prototype`. In some engines creating an // instance in this way is faster than calling `Object.create(null)` directly. // If `Object.create(null)` is not supported we prefix the event names with a // character to make sure that the built-in object properties are not // overridden or used as an attack vector. // if (Object.create) { Events.prototype = Object.create(null); // // This hack is needed because the `__proto__` property is still inherited in // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5. // if (!new Events().__proto__) prefix = false; } /** * Representation of a single event listener. * * @param {Function} fn The listener function. * @param {*} context The context to invoke the listener with. * @param {Boolean} [once=false] Specify if the listener is a one-time listener. * @constructor * @private */ function EE(fn, context, once) { this.fn = fn; this.context = context; this.once = once || false; } /** * Add a listener for a given event. * * @param {EventEmitter} emitter Reference to the `EventEmitter` instance. * @param {(String|Symbol)} event The event name. * @param {Function} fn The listener function. * @param {*} context The context to invoke the listener with. * @param {Boolean} once Specify if the listener is a one-time listener. * @returns {EventEmitter} * @private */ function addListener(emitter, event, fn, context, once) { if (typeof fn !== 'function') { throw new TypeError('The listener must be a function'); } var listener = new EE(fn, context || emitter, once) , evt = prefix ? prefix + event : event; if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++; else if (!emitter._events[evt].fn) emitter._events[evt].push(listener); else emitter._events[evt] = [emitter._events[evt], listener]; return emitter; } /** * Clear event by name. * * @param {EventEmitter} emitter Reference to the `EventEmitter` instance. * @param {(String|Symbol)} evt The Event name. * @private */ function clearEvent(emitter, evt) { if (--emitter._eventsCount === 0) emitter._events = new Events(); else delete emitter._events[evt]; } /** * Minimal `EventEmitter` interface that is molded against the Node.js * `EventEmitter` interface. * * @constructor * @public */ function EventEmitter() { this._events = new Events(); this._eventsCount = 0; } /** * Return an array listing the events for which the emitter has registered * listeners. * * @returns {Array} * @public */ EventEmitter.prototype.eventNames = function eventNames() { var names = [] , events , name; if (this._eventsCount === 0) return names; for (name in (events = this._events)) { if (has.call(events, name)) names.push(prefix ? name.slice(1) : name); } if (Object.getOwnPropertySymbols) { return names.concat(Object.getOwnPropertySymbols(events)); } return names; }; /** * Return the listeners registered for a given event. * * @param {(String|Symbol)} event The event name. * @returns {Array} The registered listeners. * @public */ EventEmitter.prototype.listeners = function listeners(event) { var evt = prefix ? prefix + event : event , handlers = this._events[evt]; if (!handlers) return []; if (handlers.fn) return [handlers.fn]; for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) { ee[i] = handlers[i].fn; } return ee; }; /** * Return the number of listeners listening to a given event. * * @param {(String|Symbol)} event The event name. * @returns {Number} The number of listeners. * @public */ EventEmitter.prototype.listenerCount = function listenerCount(event) { var evt = prefix ? prefix + event : event , listeners = this._events[evt]; if (!listeners) return 0; if (listeners.fn) return 1; return listeners.length; }; /** * Calls each of the listeners registered for a given event. * * @param {(String|Symbol)} event The event name. * @returns {Boolean} `true` if the event had listeners, else `false`. * @public */ EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) { var evt = prefix ? prefix + event : event; if (!this._events[evt]) return false; var listeners = this._events[evt] , len = arguments.length , args , i; if (listeners.fn) { if (listeners.once) this.removeListener(event, listeners.fn, undefined, true); switch (len) { case 1: return listeners.fn.call(listeners.context), true; case 2: return listeners.fn.call(listeners.context, a1), true; case 3: return listeners.fn.call(listeners.context, a1, a2), true; case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true; case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true; case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true; } for (i = 1, args = new Array(len -1); i < len; i++) { args[i - 1] = arguments[i]; } listeners.fn.apply(listeners.context, args); } else { var length = listeners.length , j; for (i = 0; i < length; i++) { if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true); switch (len) { case 1: listeners[i].fn.call(listeners[i].context); break; case 2: listeners[i].fn.call(listeners[i].context, a1); break; case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break; case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break; default: if (!args) for (j = 1, args = new Array(len -1); j < len; j++) { args[j - 1] = arguments[j]; } listeners[i].fn.apply(listeners[i].context, args); } } } return true; }; /** * Add a listener for a given event. * * @param {(String|Symbol)} event The event name. * @param {Function} fn The listener function. * @param {*} [context=this] The context to invoke the listener with. * @returns {EventEmitter} `this`. * @public */ EventEmitter.prototype.on = function on(event, fn, context) { return addListener(this, event, fn, context, false); }; /** * Add a one-time listener for a given event. * * @param {(String|Symbol)} event The event name. * @param {Function} fn The listener function. * @param {*} [context=this] The context to invoke the listener with. * @returns {EventEmitter} `this`. * @public */ EventEmitter.prototype.once = function once(event, fn, context) { return addListener(this, event, fn, context, true); }; /** * Remove the listeners of a given event. * * @param {(String|Symbol)} event The event name. * @param {Function} fn Only remove the listeners that match this function. * @param {*} context Only remove the listeners that have this context. * @param {Boolean} once Only remove one-time listeners. * @returns {EventEmitter} `this`. * @public */ EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) { var evt = prefix ? prefix + event : event; if (!this._events[evt]) return this; if (!fn) { clearEvent(this, evt); return this; } var listeners = this._events[evt]; if (listeners.fn) { if ( listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context) ) { clearEvent(this, evt); } } else { for (var i = 0, events = [], length = listeners.length; i < length; i++) { if ( listeners[i].fn !== fn || (once && !listeners[i].once) || (context && listeners[i].context !== context) ) { events.push(listeners[i]); } } // // Reset the array, or remove it completely if we have no more listeners. // if (events.length) this._events[evt] = events.length === 1 ? events[0] : events; else clearEvent(this, evt); } return this; }; /** * Remove all listeners, or those of the specified event. * * @param {(String|Symbol)} [event] The event name. * @returns {EventEmitter} `this`. * @public */ EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) { var evt; if (event) { evt = prefix ? prefix + event : event; if (this._events[evt]) clearEvent(this, evt); } else { this._events = new Events(); this._eventsCount = 0; } return this; }; // // Alias methods names because people roll like that. // EventEmitter.prototype.off = EventEmitter.prototype.removeListener; EventEmitter.prototype.addListener = EventEmitter.prototype.on; // // Expose the prefix. // EventEmitter.prefixed = prefix; // // Allow `EventEmitter` to be imported as module namespace. // EventEmitter.EventEmitter = EventEmitter; // // Expose the module. // if ('undefined' !== typeof module) { module.exports = EventEmitter; } eventemitter3-4.0.7/package.json000066400000000000000000000027271372167374400166340ustar00rootroot00000000000000{ "name": "eventemitter3", "version": "4.0.7", "description": "EventEmitter3 focuses on performance while maintaining a Node.js AND browser compatible interface.", "main": "index.js", "typings": "index.d.ts", "scripts": { "browserify": "rm -rf umd && mkdir umd && browserify index.js -s EventEmitter3 -o umd/eventemitter3.js", "minify": "uglifyjs umd/eventemitter3.js --source-map -cm -o umd/eventemitter3.min.js", "benchmark": "find benchmarks/run -name '*.js' -exec benchmarks/start.sh {} \\;", "test": "nyc --reporter=html --reporter=text mocha test/test.js", "prepublishOnly": "npm run browserify && npm run minify", "test-browser": "node test/browser.js" }, "files": [ "index.js", "index.d.ts", "umd" ], "repository": { "type": "git", "url": "git://github.com/primus/eventemitter3.git" }, "keywords": [ "EventEmitter", "EventEmitter2", "EventEmitter3", "Events", "addEventListener", "addListener", "emit", "emits", "emitter", "event", "once", "pub/sub", "publish", "reactor", "subscribe" ], "author": "Arnout Kazemier", "license": "MIT", "bugs": { "url": "https://github.com/primus/eventemitter3/issues" }, "devDependencies": { "assume": "^2.2.0", "browserify": "^16.5.0", "mocha": "^8.0.1", "nyc": "^15.1.0", "pre-commit": "^1.2.0", "sauce-browsers": "^2.0.0", "sauce-test": "^1.3.3", "uglify-js": "^3.9.0" } } eventemitter3-4.0.7/test/000077500000000000000000000000001372167374400153155ustar00rootroot00000000000000eventemitter3-4.0.7/test/browser.js000066400000000000000000000023001372167374400173310ustar00rootroot00000000000000'use strict'; const sauceBrowsers = require('sauce-browsers'); const run = require('sauce-test'); const path = require('path'); const pkg = require('../package'); const platforms = sauceBrowsers([ { name: 'android', version: ['oldest', 'latest'] }, { name: 'chrome', version: ['oldest', 'latest'] }, { name: 'firefox', version: ['oldest', 'latest'] }, { name: 'internet explorer', version: 'oldest..latest' }, { name: 'iphone', version: ['oldest', 'latest'] }, { name: 'safari', version: ['oldest', 'latest'] }, { name: 'microsoftedge', version: ['oldest', 'latest'] } ]).then((platforms) => { return platforms.map((platform) => { const ret = { browserName: platform.api_name, version: platform.short_version, platform: platform.os }; if (ret.browserName === 'android') ret.deviceName = platform.long_name; return ret; }); }); run(path.join(__dirname, 'test.js'), 'saucelabs', { html: path.join(__dirname, 'index.html'), accessKey: process.env.SAUCE_ACCESS_KEY, username: process.env.SAUCE_USERNAME, browserify: true, disableSSL: true, name: pkg.name, parallel: 5, platforms }).done((results) => { if (!results.passed) process.exit(1); }); eventemitter3-4.0.7/test/index.html000066400000000000000000000013711372167374400173140ustar00rootroot00000000000000
{{scripts}} eventemitter3-4.0.7/test/test.js000066400000000000000000000417231372167374400166410ustar00rootroot00000000000000describe('EventEmitter', function tests() { 'use strict'; var EventEmitter = require('../') , assume = require('assume'); it('exposes a `prefixed` property', function () { assume(EventEmitter.prefixed).is.either([false, '~']); }); it('exposes a module namespace object', function() { assume(EventEmitter.EventEmitter).equals(EventEmitter); }); it('inherits when used with `require("util").inherits`', function () { function Beast() { EventEmitter.call(this); } require('util').inherits(Beast, EventEmitter); var moop = new Beast() , meap = new Beast(); assume(moop).is.instanceOf(Beast); assume(moop).is.instanceOf(EventEmitter); moop.listeners(); meap.listeners(); moop.on('data', function () { throw new Error('I should not emit'); }); meap.emit('data', 'rawr'); meap.removeListener('foo'); meap.removeAllListeners(); }); if ('undefined' !== typeof Symbol) it('works with ES6 symbols', function (next) { var e = new EventEmitter() , event = Symbol('cows') , unknown = Symbol('moo'); e.on(event, function foo(arg) { assume(e.listenerCount(unknown)).equals(0); assume(e.listeners(unknown)).deep.equals([]); assume(arg).equals('bar'); function bar(onced) { assume(e.listenerCount(unknown)).equals(0); assume(e.listeners(unknown)).deep.equals([]); assume(onced).equals('foo'); next(); } e.once(unknown, bar); assume(e.listenerCount(event)).equals(1); assume(e.listeners(event)).deep.equals([foo]); assume(e.listenerCount(unknown)).equals(1); assume(e.listeners(unknown)).deep.equals([bar]); e.removeListener(event); assume(e.listenerCount(event)).equals(0); assume(e.listeners(event)).deep.equals([]); assume(e.emit(unknown, 'foo')).equals(true); }); assume(e.emit(unknown, 'bar')).equals(false); assume(e.emit(event, 'bar')).equals(true); }); describe('EventEmitter#emit', function () { it('should return false when there are not events to emit', function () { var e = new EventEmitter(); assume(e.emit('foo')).equals(false); assume(e.emit('bar')).equals(false); }); it('emits with context', function (done) { var context = { bar: 'baz' } , e = new EventEmitter(); e.on('foo', function (bar) { assume(bar).equals('bar'); assume(this).equals(context); done(); }, context).emit('foo', 'bar'); }); it('emits with context, multiple arguments (force apply)', function (done) { var context = { bar: 'baz' } , e = new EventEmitter(); e.on('foo', function (bar) { assume(bar).equals('bar'); assume(this).equals(context); done(); }, context).emit('foo', 'bar', 1, 2, 3, 4, 5, 6, 7, 8, 9, 0); }); it('can emit the function with multiple arguments', function () { var e = new EventEmitter(); for (var i = 0; i < 100; i++) { (function (j) { for (var i = 0, args = []; i < j; i++) { args.push(j); } e.once('args', function () { assume(arguments.length).equals(args.length); }); e.emit.apply(e, ['args'].concat(args)); })(i); } }); it('can emit the function with multiple arguments, multiple listeners', function () { var e = new EventEmitter(); for (var i = 0; i < 100; i++) { (function (j) { for (var i = 0, args = []; i < j; i++) { args.push(j); } e.once('args', function () { assume(arguments.length).equals(args.length); }); e.once('args', function () { assume(arguments.length).equals(args.length); }); e.once('args', function () { assume(arguments.length).equals(args.length); }); e.once('args', function () { assume(arguments.length).equals(args.length); }); e.emit.apply(e, ['args'].concat(args)); })(i); } }); it('emits with context, multiple listeners (force loop)', function () { var e = new EventEmitter(); e.on('foo', function (bar) { assume(this).eqls({ foo: 'bar' }); assume(bar).equals('bar'); }, { foo: 'bar' }); e.on('foo', function (bar) { assume(this).eqls({ bar: 'baz' }); assume(bar).equals('bar'); }, { bar: 'baz' }); e.emit('foo', 'bar'); }); it('emits with different contexts', function () { var e = new EventEmitter() , pattern = ''; function writer() { pattern += this; } e.on('write', writer, 'foo'); e.on('write', writer, 'baz'); e.once('write', writer, 'bar'); e.once('write', writer, 'banana'); e.emit('write'); assume(pattern).equals('foobazbarbanana'); }); it('should return true when there are events to emit', function () { var e = new EventEmitter() , called = 0; e.on('foo', function () { called++; }); assume(e.emit('foo')).equals(true); assume(e.emit('foob')).equals(false); assume(called).equals(1); }); it('receives the emitted events', function (done) { var e = new EventEmitter(); e.on('data', function (a, b, c, d, undef) { assume(a).equals('foo'); assume(b).equals(e); assume(c).is.instanceOf(Date); assume(undef).equals(undefined); assume(arguments.length).equals(3); done(); }); e.emit('data', 'foo', e, new Date()); }); it('emits to all event listeners', function () { var e = new EventEmitter() , pattern = []; e.on('foo', function () { pattern.push('foo1'); }); e.on('foo', function () { pattern.push('foo2'); }); e.emit('foo'); assume(pattern.join(';')).equals('foo1;foo2'); }); (function each(keys) { var key = keys.shift(); if (!key) return; it('can store event which is a known property: '+ key, function (next) { var e = new EventEmitter(); e.on(key, function (k) { assume(k).equals(key); next(); }).emit(key, key); }); each(keys); })([ 'hasOwnProperty', 'constructor', '__proto__', 'toString', 'toValue', 'unwatch', 'watch' ]); }); describe('EventEmitter#listeners', function () { it('returns an empty array if no listeners are specified', function () { var e = new EventEmitter(); assume(e.listeners('foo')).is.a('array'); assume(e.listeners('foo').length).equals(0); }); it('returns an array of function', function () { var e = new EventEmitter(); function foo() {} e.on('foo', foo); assume(e.listeners('foo')).is.a('array'); assume(e.listeners('foo').length).equals(1); assume(e.listeners('foo')).deep.equals([foo]); }); it('is not vulnerable to modifications', function () { var e = new EventEmitter(); function foo() {} e.on('foo', foo); assume(e.listeners('foo')).deep.equals([foo]); e.listeners('foo').length = 0; assume(e.listeners('foo')).deep.equals([foo]); }); }); describe('EventEmitter#listenerCount', function () { it('returns the number of listeners for a given event', function () { var e = new EventEmitter(); assume(e.listenerCount()).equals(0); assume(e.listenerCount('foo')).equals(0); e.on('foo', function () {}); assume(e.listenerCount('foo')).equals(1); e.on('foo', function () {}); assume(e.listenerCount('foo')).equals(2); }); }); describe('EventEmitter#on', function () { it('throws an error if the listener is not a function', function () { var e = new EventEmitter(); try { e.on('foo', 'bar'); } catch (ex) { assume(ex).is.instanceOf(TypeError); assume(ex.message).equals('The listener must be a function'); return; } throw new Error('oops'); }); }); describe('EventEmitter#once', function () { it('only emits it once', function () { var e = new EventEmitter() , calls = 0; e.once('foo', function () { calls++; }); e.emit('foo'); e.emit('foo'); e.emit('foo'); e.emit('foo'); e.emit('foo'); assume(e.listeners('foo').length).equals(0); assume(calls).equals(1); }); it('only emits once if emits are nested inside the listener', function () { var e = new EventEmitter() , calls = 0; e.once('foo', function () { calls++; e.emit('foo'); }); e.emit('foo'); assume(e.listeners('foo').length).equals(0); assume(calls).equals(1); }); it('only emits once for multiple events', function () { var e = new EventEmitter() , multi = 0 , foo = 0 , bar = 0; e.once('foo', function () { foo++; }); e.once('foo', function () { bar++; }); e.on('foo', function () { multi++; }); e.emit('foo'); e.emit('foo'); e.emit('foo'); e.emit('foo'); e.emit('foo'); assume(e.listeners('foo').length).equals(1); assume(multi).equals(5); assume(foo).equals(1); assume(bar).equals(1); }); it('only emits once with context', function (done) { var context = { foo: 'bar' } , e = new EventEmitter(); e.once('foo', function (bar) { assume(this).equals(context); assume(bar).equals('bar'); done(); }, context).emit('foo', 'bar'); }); }); describe('EventEmitter#removeListener', function () { it('removes all listeners when the listener is not specified', function () { var e = new EventEmitter(); e.on('foo', function () {}); e.on('foo', function () {}); assume(e.removeListener('foo')).equals(e); assume(e.listeners('foo')).eql([]); }); it('removes only the listeners matching the specified listener', function () { var e = new EventEmitter(); function foo() {} function bar() {} function baz() {} e.on('foo', foo); e.on('bar', bar); e.on('bar', baz); assume(e.removeListener('foo', bar)).equals(e); assume(e.listeners('bar')).eql([bar, baz]); assume(e.listeners('foo')).eql([foo]); assume(e._eventsCount).equals(2); assume(e.removeListener('foo', foo)).equals(e); assume(e.listeners('bar')).eql([bar, baz]); assume(e.listeners('foo')).eql([]); assume(e._eventsCount).equals(1); assume(e.removeListener('bar', bar)).equals(e); assume(e.listeners('bar')).eql([baz]); assume(e._eventsCount).equals(1); assume(e.removeListener('bar', baz)).equals(e); assume(e.listeners('bar')).eql([]); assume(e._eventsCount).equals(0); e.on('foo', foo); e.on('foo', foo); e.on('bar', bar); assume(e.removeListener('foo', foo)).equals(e); assume(e.listeners('bar')).eql([bar]); assume(e.listeners('foo')).eql([]); assume(e._eventsCount).equals(1); }); it('removes only the once listeners when using the once flag', function () { var e = new EventEmitter(); function foo() {} e.on('foo', foo); assume(e.removeListener('foo', function () {}, undefined, true)).equals(e); assume(e.listeners('foo')).eql([foo]); assume(e._eventsCount).equals(1); assume(e.removeListener('foo', foo, undefined, true)).equals(e); assume(e.listeners('foo')).eql([foo]); assume(e._eventsCount).equals(1); assume(e.removeListener('foo', foo)).equals(e); assume(e.listeners('foo')).eql([]); assume(e._eventsCount).equals(0); e.once('foo', foo); e.on('foo', foo); assume(e.removeListener('foo', function () {}, undefined, true)).equals(e); assume(e.listeners('foo')).eql([foo, foo]); assume(e._eventsCount).equals(1); assume(e.removeListener('foo', foo, undefined, true)).equals(e); assume(e.listeners('foo')).eql([foo]); assume(e._eventsCount).equals(1); e.once('foo', foo); assume(e.removeListener('foo', foo)).equals(e); assume(e.listeners('foo')).eql([]); assume(e._eventsCount).equals(0); }); it('removes only the listeners matching the correct context', function () { var context = { foo: 'bar' } , e = new EventEmitter(); function foo() {} function bar() {} e.on('foo', foo, context); assume(e.removeListener('foo', function () {}, context)).equals(e); assume(e.listeners('foo')).eql([foo]); assume(e._eventsCount).equals(1); assume(e.removeListener('foo', foo, { baz: 'quux' })).equals(e); assume(e.listeners('foo')).eql([foo]); assume(e._eventsCount).equals(1); assume(e.removeListener('foo', foo, context)).equals(e); assume(e.listeners('foo')).eql([]); assume(e._eventsCount).equals(0); e.on('foo', foo, context); e.on('foo', bar); assume(e.removeListener('foo', foo, { baz: 'quux' })).equals(e); assume(e.listeners('foo')).eql([foo, bar]); assume(e._eventsCount).equals(1); assume(e.removeListener('foo', foo, context)).equals(e); assume(e.listeners('foo')).eql([bar]); assume(e._eventsCount).equals(1); e.on('foo', bar, context); assume(e.removeListener('foo', bar)).equals(e); assume(e.listeners('foo')).eql([]); assume(e._eventsCount).equals(0); }); }); describe('EventEmitter#removeAllListeners', function () { it('removes all events for the specified events', function () { var e = new EventEmitter(); e.on('foo', function () { throw new Error('oops'); }); e.on('foo', function () { throw new Error('oops'); }); e.on('bar', function () { throw new Error('oops'); }); e.on('aaa', function () { throw new Error('oops'); }); assume(e.removeAllListeners('foo')).equals(e); assume(e.listeners('foo').length).equals(0); assume(e.listeners('bar').length).equals(1); assume(e.listeners('aaa').length).equals(1); assume(e._eventsCount).equals(2); assume(e.removeAllListeners('bar')).equals(e); assume(e._eventsCount).equals(1); assume(e.removeAllListeners('aaa')).equals(e); assume(e._eventsCount).equals(0); assume(e.emit('foo')).equals(false); assume(e.emit('bar')).equals(false); assume(e.emit('aaa')).equals(false); }); it('just nukes the fuck out of everything', function () { var e = new EventEmitter(); e.on('foo', function () { throw new Error('oops'); }); e.on('foo', function () { throw new Error('oops'); }); e.on('bar', function () { throw new Error('oops'); }); e.on('aaa', function () { throw new Error('oops'); }); assume(e.removeAllListeners()).equals(e); assume(e.listeners('foo').length).equals(0); assume(e.listeners('bar').length).equals(0); assume(e.listeners('aaa').length).equals(0); assume(e._eventsCount).equals(0); assume(e.emit('foo')).equals(false); assume(e.emit('bar')).equals(false); assume(e.emit('aaa')).equals(false); }); }); describe('EventEmitter#eventNames', function () { it('returns an empty array when there are no events', function () { var e = new EventEmitter(); assume(e.eventNames()).eql([]); e.on('foo', function () {}); e.removeAllListeners('foo'); assume(e.eventNames()).eql([]); }); it('returns an array listing the events that have listeners', function () { var e = new EventEmitter() , original; function bar() {} if (Object.getOwnPropertySymbols) { // // Monkey patch `Object.getOwnPropertySymbols()` to increase coverage // on Node.js > 0.10. // original = Object.getOwnPropertySymbols; Object.getOwnPropertySymbols = undefined; } e.on('foo', function () {}); e.on('bar', bar); try { assume(e.eventNames()).eql(['foo', 'bar']); e.removeListener('bar', bar); assume(e.eventNames()).eql(['foo']); } catch (ex) { throw ex; } finally { if (original) Object.getOwnPropertySymbols = original; } }); it('does not return inherited property identifiers', function () { var e = new EventEmitter(); function Collection() {} Collection.prototype.foo = function () { return 'foo'; }; e._events = new Collection(); assume(e._events.foo()).equal('foo'); assume(e.eventNames()).eql([]); }); if ('undefined' !== typeof Symbol) it('includes ES6 symbols', function () { var e = new EventEmitter() , s = Symbol('s'); function foo() {} e.on('foo', foo); e.on(s, function () {}); assume(e.eventNames()).eql(['foo', s]); e.removeListener('foo', foo); assume(e.eventNames()).eql([s]); }); }); });