pax_global_header00006660000000000000000000000064142720000510014501gustar00rootroot0000000000000052 comment=3485e7ebaaed21dd0121c1924beda0817af77328 EventEmitter2-6.4.7/000077500000000000000000000000001427200005100142145ustar00rootroot00000000000000EventEmitter2-6.4.7/.gitignore000066400000000000000000000002101427200005100161750ustar00rootroot00000000000000#ignore these files *.swp *~ *.lock *.DS_Store node_modules npm-debug.log *.out *.o *.tmp .idea .nyc_output coverage package-lock.json EventEmitter2-6.4.7/.travis.yml000066400000000000000000000002321427200005100163220ustar00rootroot00000000000000sudo: false language: node_js node_js: - "8" - "10" env: - NODE_ENV=TEST script: - npm run test:coverage after_success: npm run coveralls EventEmitter2-6.4.7/CHANGELOG.md000066400000000000000000000073601427200005100160330ustar00rootroot00000000000000# Change Log All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/). For changes before version 2.2.0, please see the commit history # [6.4.5] - 2021-10-03 ### Fixed - invoking a wildcard listener when there is also a matching exact listener (#278) @DigitalBrainJS # [6.4.4] - 2021-02-23 ### Added - `ETIMEDOUT` code property to timeout errors @HalleyAssist ### Fixed - prepending listeners to wildcard emitters @Ilrilan # [6.4.3] - 2020-06-18 ### Fixed - ignoring the `objectify` option in wildcard mode (#265) @DigitalBrainJS - waitFor listeners leakage issue (#262) @DigitalBrainJS ## [6.4.2] - 2020-05-28 ### Fixed - removed eval usage to avoid Content Security Policy issue (#259) @DigitalBrainJS ## [6.4.1] - 2020-05-10 ### Fixed - increased emitter performance in wildcard mode @DigitalBrainJS ## [6.4.0] - 2020-05-04 ### Added - Symbol events support for simple and wildcard emitters #201 @DigitalBrainJS - `emitter.hasListeners` method #251 @DigitalBrainJS - `emitter.listenTo` & `emitter.stopListeningTo` methods for listening to an external event emitter of any kind and propagate its events through itself using optional reducers/filters @DigitalBrainJS - async listeners for invoking handlers using setImmediate|setTimeout|nextTick (see `async`, `promisify` and `nextTicks` options for subscription methods) @DigitalBrainJS - Ability for subscription methods to return a listener object to simplify subscription management (see the `objectify` option) @DigitalBrainJS - micro optimizations for performance reasons @DigitalBrainJS ### Fixed - Event name/reference normalization for the `this.event` property #162 @DigitalBrainJS - Bug with data arguments for `Any` listeners #254 @DigitalBrainJS - `emitter.eventNames` now supports wildcard emitters #214 @DigitalBrainJS ## [6.3.0] - 2020-03-28 ### Added - emitter.getMaxListeners() & EventEmitter2.defaultMaxListeners() @DigitalBrainJS - EventEmitter2.once for feature parity with EventEmitter.once @DigitalBrainJS ## [6.2.1] - 2020-03-20 ### Fixed - #153 - global scope is no longer defaulted to the `window` variable, now supports workers. @DigitalBrainJS ## [6.2.0] - 2020-03-20 ### Added - `waitFor` method to wait for events using promises @DigitalBrainJS ## [6.1.0] - 2020-03-19 ### Added - `ignoreErrors` errors option in constructor @DigitalBrainJS ## [5.0.1] - 2018-01-09 ### Fixed - Allow `removeAllListeners` to receive `undefined` as an argument. @majames ## [4.1.2] - 2017-07-12 ### Added - Correct listeners and listenersAny typings @cartant ## [4.1.1] - 2017-03-29 ### Added - Use process.emitWarning if it is available (new Node.js) @SimenB ## [4.0.0] - 2017-03-22 ### Fixed - Fix for EventAndListener in typescript definition. @thisboyiscrazy ### Added - New Node 6 APIs such as `prependListener` and `eventNames`. @sebakerckhof ## [3.0.2] - 2017-03-06 ### Fixed - Fixed `emitAsync` when using `once`. @Moeriki ## [3.0.1] - 2017-02-21 ### Changed - Changed Typescript definition to take array of strings for event name. @thisboyiscrazy ## [3.0.0] - 2017-01-23 ### Changed - Typescript definition now uses `EventEmitter2` instead of `EventEmitter2.eitter`. @gitawego ## [2.2.2] - 2017-01-17 ### Fixed - Typescript definition for `removeAllListeners` can take an array. @gitawego ## [2.2.1] - 2016-11-24 ### Added - Added missing parameters for emitAsync in typescript definition. @stanleytakamatsu ## [2.2.0] - 2016-11-14 ### Added - option to emit name of event that causes memory leak warning. @kwiateusz ### Fixed - component.json and bower.json got updated with latest version. @kwiateusz - missing globals in test suite got added in. @kwiateusz EventEmitter2-6.4.7/CONTRIBUTING.md000066400000000000000000000023211427200005100164430ustar00rootroot00000000000000## This is an **OPEN Open Source Projects** ----------------------------------------- ## What? Individuals making significant and valuable contributions are given commit-access to a project to contribute as they see fit. A project is more like an open wiki than a standard guarded open source project. ## Rules There are a few basic ground-rules for contributors: 1. **No `--force` pushes** or modifying the Git history in any way. 1. **Non-master branches** ought to be used for ongoing work. 1. **External API changes and significant modifications** ought to be subject to an **internal pull-request** to solicit feedback from other contributors. 1. Internal pull-requests to solicit feedback are *encouraged* for any other non-trivial contribution but left to the discretion of the contributor. 1. Contributors should attempt to adhere to the prevailing code-style. ## Releases Declaring formal releases remains the prerogative of the project maintainer(s). ## Changes to this arrangement This is an experiment and feedback is welcome! This document may also be subject to pull-requests or changes by contributors where you believe you have something valuable to add or change. ----------------------------------------- EventEmitter2-6.4.7/LICENSE.txt000066400000000000000000000021611427200005100160370ustar00rootroot00000000000000 The MIT License (MIT) Copyright (c) 2016 Paolo Fragomeni and Contributors 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. EventEmitter2-6.4.7/README.md000066400000000000000000000667321427200005100155110ustar00rootroot00000000000000[![Build Status](https://travis-ci.org/EventEmitter2/EventEmitter2.svg?branch=master)](https://travis-ci.org/EventEmitter2/EventEmitter2) [![Coverage Status](https://coveralls.io/repos/github/EventEmitter2/EventEmitter2/badge.svg?branch=v6.4.3)](https://coveralls.io/github/EventEmitter2/EventEmitter2?branch=v6.4.3) [![NPM version](https://badge.fury.io/js/eventemitter2.svg)](http://badge.fury.io/js/eventemitter2) [![Dependency Status](https://img.shields.io/david/asyncly/eventemitter2.svg)](https://david-dm.org/asyncly/eventemitter2) [![npm](https://img.shields.io/npm/dm/eventemitter2.svg?maxAge=2592000)]() # SYNOPSIS EventEmitter2 is an implementation of the EventEmitter module found in Node.js. In addition to having a better benchmark performance than EventEmitter and being browser-compatible, it also extends the interface of EventEmitter with many additional non-breaking features. If you like this project please show your support with a [GitHub :star:](https://github.com/EventEmitter2/EventEmitter2/stargazers)! # DESCRIPTION ### FEATURES - ES5 compatible UMD module, that supports node.js, browser and workers of any kind - Namespaces/Wildcards - [Any](#emitteronanylistener) listeners - Times To Listen (TTL), extends the `once` concept with [`many`](#emittermanyevent--eventns-timestolisten-listener-options) - [Async listeners](#emitteronevent-listener-options-objectboolean) (using setImmediate|setTimeout|nextTick) with promise|async function support - The [emitAsync](#emitteremitasyncevent--eventns-arg1-arg2-) method to return the results of the listeners via Promise.all - Subscription methods ([on](#emitteronevent-listener-options-objectboolean), [once](#emitterprependoncelistenerevent--eventns-listener-options), [many](#emittermanyevent--eventns-timestolisten-listener-options), ...) can return a [listener](#listener) object that makes it easy to remove the subscription when needed - just call the listener.off() method. - Feature-rich [waitFor](#emitterwaitforevent--eventns-options) method to wait for events using promises - [listenTo](#listentotargetemitter-events-objectevent--eventns-function-options) & [stopListeningTo](#stoplisteningtotarget-object-event-event--eventns-boolean) methods for listening to an external event emitter of any kind and propagate its events through itself using optional reducers/filters - Extended version of the [events.once](#eventemitter2onceemitter-event--eventns-options) method from the [node events API](https://nodejs.org/api/events.html#events_events_once_emitter_name) - Browser & Workers environment compatibility - Demonstrates good performance in benchmarks ``` Platform: win32, x64, 15267MB Node version: v13.11.0 CPU: 4 x AMD Ryzen 3 2200U with Radeon Vega Mobile Gfx @ 2495MHz ---------------------------------------------------------------- EventEmitterHeatUp x 2,897,056 ops/sec ±3.86% (67 runs sampled) EventEmitter x 3,232,934 ops/sec ±3.50% (65 runs sampled) EventEmitter2 x 12,261,042 ops/sec ±4.72% (59 runs sampled) EventEmitter2 (wild) x 242,751 ops/sec ±5.15% (68 runs sampled) EventEmitter2 (wild) using plain events x 358,916 ops/sec ±2.58% (78 runs sampled) EventEmitter2 (wild) emitting ns x 1,837,323 ops/sec ±3.50% (72 runs sampled) EventEmitter2 (wild) emitting a plain event x 2,743,707 ops/sec ±4.08% (65 runs sampled) EventEmitter3 x 10,380,258 ops/sec ±3.93% (67 runs sampled) Fastest is EventEmitter2 ``` ### What's new To find out what's new see the project [CHANGELOG](https://github.com/EventEmitter2/EventEmitter2/blob/master/CHANGELOG.md) ### Differences (Non-breaking, compatible with existing EventEmitter) - The EventEmitter2 constructor takes an optional configuration object with the following default values: ```javascript var EventEmitter2 = require('eventemitter2'); var emitter = new EventEmitter2({ // set this to `true` to use wildcards wildcard: false, // the delimiter used to segment namespaces delimiter: '.', // set this to `true` if you want to emit the newListener event newListener: false, // set this to `true` if you want to emit the removeListener event removeListener: false, // the maximum amount of listeners that can be assigned to an event maxListeners: 10, // show event name in memory leak message when more than maximum amount of listeners is assigned verboseMemoryLeak: false, // disable throwing uncaughtException if an error event is emitted and it has no listeners ignoreErrors: false }); ``` - Getting the actual event that fired. ```javascript emitter.on('foo.*', function(value1, value2) { console.log(this.event, value1, value2); }); emitter.emit('foo.bar', 1, 2); // 'foo.bar' 1 2 emitter.emit(['foo', 'bar'], 3, 4); // 'foo.bar' 3 4 emitter.emit(Symbol(), 5, 6); // Symbol() 5 6 emitter.emit(['foo', Symbol()], 7, 8); // ['foo', Symbol()] 7 8 ``` **Note**: Generally this.event is normalized to a string ('event', 'event.test'), except the cases when event is a symbol or namespace contains a symbol. In these cases this.event remains as is (symbol and array). - Fire an event N times and then remove it, an extension of the `once` concept. ```javascript emitter.many('foo', 4, function() { console.log('hello'); }); ``` - Pass in a namespaced event as an array rather than a delimited string. ```javascript emitter.many(['foo', 'bar', 'bazz'], 4, function() { console.log('hello'); }); ``` # Installing ```console $ npm install eventemitter2 ``` Or you can use unpkg.com CDN to import this [module](https://unpkg.com/eventemitter2) as a script directly from the browser # API ### Types definition - `Event`: string | symbol - `EventNS`: string | Event [] ## Class EventEmitter2 ### instance: - [emit(event: event | eventNS, ...values: any[]): boolean](#emitteremitevent--eventns-arg1-arg2-); - [emitAsync(event: event | eventNS, ...values: any[]): Promise](#emitteremitasyncevent--eventns-arg1-arg2-) - [addListener(event: event | eventNS, listener: ListenerFn, boolean|options?: object): this|Listener](#emitteraddlistenerevent-listener-options-objectboolean) - [on(event: event | eventNS, listener: ListenerFn, boolean|options?: object): this|Listener](#emitteraddlistenerevent-listener-options-objectboolean) - [once(event: event | eventNS, listener: ListenerFn, boolean|options?: object): this|Listener](#emitteronceevent--eventns-listener-options) - [many(event: event | eventNS, timesToListen: number, listener: ListenerFn, boolean|options?: object): this|Listener](#emittermanyevent--eventns-timestolisten-listener-options) - [prependMany(event: event | eventNS, timesToListen: number, listener: ListenerFn, boolean|options?: object): this|Listener](#emitterprependanylistener) - [prependOnceListener(event: event | eventNS, listener: ListenerFn, boolean|options?: object): this|Listener](#emitterprependoncelistenerevent--eventns-listener-options) - [prependListener(event: event | eventNS, listener: ListenerFn, boolean|options?: object): this|Listener](#emitterprependlistenerevent-listener-options) - [prependAny(listener: EventAndListener): this](#emitterprependanylistener) - [onAny(listener: EventAndListener): this](#emitteronanylistener) - [offAny(listener: ListenerFn): this](#emitteroffanylistener) - [removeListener(event: event | eventNS, listener: ListenerFn): this](#emitterremovelistenerevent--eventns-listener) - [off(event: event | eventNS, listener: ListenerFn): this](#emitteroffevent--eventns-listener) - [removeAllListeners(event?: event | eventNS): this](#emitterremovealllistenersevent--eventns) - [setMaxListeners(n: number): void](#emittersetmaxlistenersn) - [getMaxListeners(): number](#emittergetmaxlisteners) - [eventNames(nsAsArray?: boolean): string[]](#emittereventnamesnsasarray) - [listeners(event: event | eventNS): ListenerFn[]](#emitterlistenersevent--eventns) - [listenersAny(): ListenerFn[]](#emitterlistenersany) - [hasListeners(event?: event | eventNS): Boolean](#haslistenersevent--eventnsstringboolean) - [waitFor(event: event | eventNS, timeout?: number): CancelablePromise](#emitterwaitforevent--eventns-timeout) - [waitFor(event: event | eventNS, filter?: WaitForFilter): CancelablePromise](#emitterwaitforevent--eventns-filter) - [waitFor(event: event | eventNS, options?: WaitForOptions): CancelablePromise](#emitterwaitforevent--eventns-options) - [listenTo(target: GeneralEventEmitter, event: event | eventNS, options?: ListenToOptions): this](#listentotargetemitter-events-objectevent--eventns-function-options) - [listenTo(target: GeneralEventEmitter, events: (event | eventNS)[], options?: ListenToOptions): this](#listentotargetemitter-events-event--eventns-options) - [listenTo(target: GeneralEventEmitter, events: Object, options?: ListenToOptions): this](#listentotargetemitter-events-objectevent--eventns-function-options) - [stopListeningTo(target?: GeneralEventEmitter, event?: event | eventNS): Boolean](#stoplisteningtarget-object-event-event--eventns-boolean) ### static: - [static once(emitter: EventEmitter2, event: string | symbol, options?: OnceOptions): CancelablePromise](#eventemitter2onceemitter-event--eventns-options) - [static defaultMaxListeners: number](#eventemitter2defaultmaxlisteners) The `event` argument specified in the API declaration can be a string or symbol for a simple event emitter and a string|symbol|Array(string|symbol) in a case of a wildcard emitter; When an `EventEmitter` instance experiences an error, the typical action is to emit an `error` event. Error events are treated as a special case. If there is no listener for it, then the default action is to print a stack trace and exit the program. All EventEmitters emit the event `newListener` when new listeners are added. EventEmitters also emit the event `removeListener` when listeners are removed, and `removeListenerAny` when listeners added through `onAny` are removed. **Namespaces** with **Wildcards** To use namespaces/wildcards, pass the `wildcard` option into the EventEmitter constructor. When namespaces/wildcards are enabled, events can either be strings (`foo.bar`) separated by a delimiter or arrays (`['foo', 'bar']`). The delimiter is also configurable as a constructor option. An event name passed to any event emitter method can contain a wild card (the `*` character). If the event name is a string, a wildcard may appear as `foo.*`. If the event name is an array, the wildcard may appear as `['foo', '*']`. If either of the above described events were passed to the `on` method, subsequent emits such as the following would be observed... ```javascript emitter.emit(Symbol()); emitter.emit('foo'); emitter.emit('foo.bazz'); emitter.emit(['foo', 'bar']); emitter.emit(['foo', Symbol()]); ``` **NOTE:** An event name may use more than one wildcard. For example, `foo.*.bar.*` is a valid event name, and would match events such as `foo.x.bar.y`, or `['foo', 'bazz', 'bar', 'test']` # Multi-level Wildcards A double wildcard (the string `**`) matches any number of levels (zero or more) of events. So if for example `'foo.**'` is passed to the `on` method, the following events would be observed: ````javascript emitter.emit('foo'); emitter.emit('foo.bar'); emitter.emit('foo.bar.baz'); emitter.emit(['foo', Symbol(), 'baz']); ```` On the other hand, if the single-wildcard event name was passed to the on method, the callback would only observe the second of these events. ### emitter.addListener(event, listener, options?: object|boolean) ### emitter.on(event, listener, options?: object|boolean) Adds a listener to the end of the listeners array for the specified event. ```javascript emitter.on('data', function(value1, value2, value3, ...) { console.log('The event was raised!'); }); ``` ```javascript emitter.on('data', function(value) { console.log('The event was raised!'); }); ``` **Options:** - `async:boolean= false`- invoke the listener in async mode using setImmediate (fallback to setTimeout if not available) or process.nextTick depending on the `nextTick` option. - `nextTick:boolean= false`- use process.nextTick instead of setImmediate to invoke the listener asynchronously. - `promisify:boolean= false`- additionally wraps the listener to a Promise for later invocation using `emitAsync` method. This option will be activated by default if its value is `undefined` and the listener function is an `asynchronous function` (whose constructor name is `AsyncFunction`). - `objectify:boolean= false`- activates returning a [listener](#listener) object instead of 'this' by the subscription method. #### listener The listener object has the following properties: - `emitter: EventEmitter2` - reference to the event emitter instance - `event: event|eventNS` - subscription event - `listener: Function` - reference to the listener - `off(): Function`- removes the listener (voids the subscription) ````javascript var listener= emitter.on('event', function(){ console.log('hello!'); }, {objectify: true}); emitter.emit('event'); listener.off(); ```` **Note:** If the options argument is `true` it will be considered as `{promisify: true}` **Note:** If the options argument is `false` it will be considered as `{async: true}` ```javascript var EventEmitter2= require('eventemitter2'); var emitter= new EventEmitter2(); emitter.on('event', function(){ console.log('The event was raised!'); }, {async: true}); emitter.emit('event'); console.log('emitted'); ``` Since the `async` option was set the output from the code above is as follows: ```` emitted The event was raised! ```` If the listener is an async function or function which returns a promise, use the `promisify` option as follows: ```javascript var EventEmitter2= require('eventemitter2'); var emitter= new EventEmitter2(); emitter.on('event', function(){ console.log('The event was raised!'); return new Promise(function(resolve){ console.log('listener resolved'); setTimeout(resolve, 1000); }); }, {promisify: true}); emitter.emitAsync('event').then(function(){ console.log('all listeners were resolved!'); }); console.log('emitted'); ```` Output: ```` emitted The event was raised! listener resolved all listeners were resolved! ```` If the `promisify` option is false (default value) the output of the same code is as follows: ```` The event was raised! listener resolved emitted all listeners were resolved! ```` ### emitter.prependListener(event, listener, options?) Adds a listener to the beginning of the listeners array for the specified event. ```javascript emitter.prependListener('data', function(value1, value2, value3, ...) { console.log('The event was raised!'); }); ``` **options:** `options?`: See the [addListener options](#emitteronevent-listener-options-objectboolean) ### emitter.onAny(listener) Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the callback. ```javascript emitter.onAny(function(event, value) { console.log('All events trigger this.'); }); ``` ### emitter.prependAny(listener) Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the callback. The listener is added to the beginning of the listeners array ```javascript emitter.prependAny(function(event, value) { console.log('All events trigger this.'); }); ``` ### emitter.offAny(listener) Removes the listener that will be fired when any event is emitted. ```javascript emitter.offAny(function(value) { console.log('The event was raised!'); }); ``` #### emitter.once(event | eventNS, listener, options?) Adds a **one time** listener for the event. The listener is invoked only the first time the event is fired, after which it is removed. ```javascript emitter.once('get', function (value) { console.log('Ah, we have our first value!'); }); ``` **options:** `options?`: See the [addListener options](#emitteronevent-listener-options-objectboolean) #### emitter.prependOnceListener(event | eventNS, listener, options?) Adds a **one time** listener for the event. The listener is invoked only the first time the event is fired, after which it is removed. The listener is added to the beginning of the listeners array ```javascript emitter.prependOnceListener('get', function (value) { console.log('Ah, we have our first value!'); }); ``` **options:** `options?`: See the [addListener options](#emitteronevent-listener-options-objectboolean) ### emitter.many(event | eventNS, timesToListen, listener, options?) Adds a listener that will execute **n times** for the event before being removed. The listener is invoked only the first **n times** the event is fired, after which it is removed. ```javascript emitter.many('get', 4, function (value) { console.log('This event will be listened to exactly four times.'); }); ``` **options:** `options?`: See the [addListener options](#emitteronevent-listener-options-objectboolean) ### emitter.prependMany(event | eventNS, timesToListen, listener, options?) Adds a listener that will execute **n times** for the event before being removed. The listener is invoked only the first **n times** the event is fired, after which it is removed. The listener is added to the beginning of the listeners array. ```javascript emitter.many('get', 4, function (value) { console.log('This event will be listened to exactly four times.'); }); ``` **options:** `options?`: See the [addListener options](#emitteronevent-listener-options-objectboolean) ### emitter.removeListener(event | eventNS, listener) ### emitter.off(event | eventNS, listener) Remove a listener from the listener array for the specified event. **Caution**: Calling this method changes the array indices in the listener array behind the listener. ```javascript var callback = function(value) { console.log('someone connected!'); }; emitter.on('get', callback); // ... emitter.removeListener('get', callback); ``` ### emitter.removeAllListeners([event | eventNS]) Removes all listeners, or those of the specified event. ### emitter.setMaxListeners(n) By default EventEmitters will print a warning if more than 10 listeners are added to it. This is a useful default which helps finding memory leaks. Obviously not all Emitters should be limited to 10. This function allows that to be increased. Set to zero for unlimited. ### emitter.getMaxListeners() Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to EventEmitter2.defaultMaxListeners ### emitter.listeners(event | eventNS) Returns an array of listeners for the specified event. This array can be manipulated, e.g. to remove listeners. ```javascript emitter.on('get', function(value) { console.log('someone connected!'); }); console.log(emitter.listeners('get')); // [ [Function] ] ``` ### emitter.listenersAny() Returns an array of listeners that are listening for any event that is specified. This array can be manipulated, e.g. to remove listeners. ```javascript emitter.onAny(function(value) { console.log('someone connected!'); }); console.log(emitter.listenersAny()[0]); // [ [Function] ] ``` ### emitter.emit(event | eventNS, [arg1], [arg2], [...]) Execute each of the listeners that may be listening for the specified event name in order with the list of arguments. ### emitter.emitAsync(event | eventNS, [arg1], [arg2], [...]) Return the results of the listeners via [Promise.all](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Promise/all). Only this method doesn't work [IE](http://caniuse.com/#search=promise). ```javascript emitter.on('get',function(i) { return new Promise(function(resolve){ setTimeout(function(){ resolve(i+3); },50); }); }); emitter.on('get',function(i) { return new Promise(function(resolve){ resolve(i+2) }); }); emitter.on('get',function(i) { return Promise.resolve(i+1); }); emitter.on('get',function(i) { return i+0; }); emitter.on('get',function(i) { // noop }); emitter.emitAsync('get',0) .then(function(results){ console.log(results); // [3,2,1,0,undefined] }); ``` ### emitter.waitFor(event | eventNS, [options]) ### emitter.waitFor(event | eventNS, [timeout]) ### emitter.waitFor(event | eventNS, [filter]) Returns a thenable object (promise interface) that resolves when a specific event occurs ````javascript emitter.waitFor('event').then(function (data) { console.log(data); // ['bar'] }); emitter.emit('event', 'bar'); ```` ````javascript emitter.waitFor('event', { // handle first event data argument as an error (err, ...data) handleError: false, // the timeout for resolving the promise before it is rejected with an error (Error: timeout). timeout: 0, //filter function to determine acceptable values for resolving the promise. filter: function(arg0, arg1){ return arg0==='foo' && arg1==='bar' }, Promise: Promise, // Promise constructor to use, overload: false // overload cancellation api in a case of external Promise class }).then(function(data){ console.log(data); // ['foo', 'bar'] }); emitter.emit('event', 'foo', 'bar') ```` ````javascript var promise= emitter.waitFor('event'); promise.then(null, function(error){ console.log(error); //Error: canceled }); promise.cancel(); //stop listening the event and reject the promise ```` ````javascript emitter.waitFor('event', { handleError: true }).then(null, function(error){ console.log(error); //Error: custom error }); emitter.emit('event', new Error('custom error')); // reject the promise ```` ### emitter.eventNames(nsAsArray) Returns an array listing the events for which the emitter has registered listeners. ```javascript var emitter= new EventEmitter2(); emitter.on('foo', () => {}); emitter.on('bar', () => {}); emitter.on(Symbol('test'), () => {}); emitter.on(['foo', Symbol('test2')], () => {}); console.log(emitter.eventNames()); // Prints: [ 'bar', 'foo', [ 'foo', Symbol(test2) ], [ 'foo', Symbol(test2) ] ] ``` **Note**: Listeners order not guaranteed ### listenTo(targetEmitter, events: event | eventNS, options?) ### listenTo(targetEmitter, events: (event | eventNS)[], options?) ### listenTo(targetEmitter, events: Object, options?) Listens to the events emitted by an external emitter and propagate them through itself. The target object could be of any type that implements methods for subscribing and unsubscribing to its events. By default this method attempts to use `addListener`/`removeListener`, `on`/`off` and `addEventListener`/`removeEventListener` pairs, but you able to define own hooks `on(event, handler)` and `off(event, handler)` in the options object to use custom subscription API. In these hooks `this` refers to the target object. The options object has the following interface: - `on(event, handler): void` - `off(event, handler): void` - `reducer: (Function) | (Object): Boolean` In case you selected the `newListener` and `removeListener` options when creating the emitter, the subscription to the events of the target object will be conditional, depending on whether there are listeners in the emitter that could listen them. ````javascript var EventEmitter2 = require('EventEmitter2'); var http = require('http'); var server = http.createServer(function(request, response){ console.log(request.url); response.end('Hello Node.js Server!') }).listen(3000); server.on('connection', function(req, socket, head){ console.log('connect'); }); // activate the ability to attach listeners on demand var emitter= new EventEmitter2({ newListener: true, removeListener: true }); emitter.listenTo(server, { 'connection': 'localConnection', 'close': 'close' }, { reducers: { connection: function(event){ console.log('event name:' + event.name); //'localConnection' console.log('original event name:' + event.original); //'connection' return event.data[0].remoteAddress==='::1'; } } }); emitter.on('localConnection', function(socket){ console.log('local connection', socket.remoteAddress); }); setTimeout(function(){ emitter.stopListeningTo(server); }, 30000); ```` An example of using a wildcard emitter in a browser: ````javascript const ee= new EventEmitter2({ wildcard: true }); ee.listenTo(document.querySelector('#test'), { 'click': 'div.click', 'mouseup': 'div.mouseup', 'mousedown': 'div.mousedown' }); ee.on('div.*', function(evt){ console.log('listenTo: '+ evt.type); }); setTimeout(function(){ ee.stopListeningTo(document.querySelector('#test')); }, 30000); ```` ### stopListeningTo(target?: Object, event: event | eventNS): Boolean Stops listening the targets. Returns true if some listener was removed. ### hasListeners(event | eventNS?:String):Boolean Checks whether emitter has any listeners. ### emitter.listeners(event | eventNS) Returns the array of listeners for the event named eventName. In wildcard mode this method returns namespaces as strings: ````javascript var emitter= new EventEmitter2({ wildcard: true }); emitter.on('a.b.c', function(){}); emitter.on(['z', 'x', 'c'], function(){}); console.log(emitter.eventNames()) // [ 'z.x.c', 'a.b.c' ] ```` If some namespace contains a Symbol member or the `nsAsArray` option is set the method will return namespace as an array of its members; ````javascript var emitter= new EventEmitter2({ wildcard: true }); emitter.on('a.b.c', function(){}); emitter.on(['z', 'x', Symbol()], function(){}); console.log(emitter.eventNames()) // [ [ 'z', 'x', Symbol() ], 'a.b.c' ] ```` ### EventEmitter2.once(emitter, event | eventNS, [options]) Creates a cancellable Promise that is fulfilled when the EventEmitter emits the given event or that is rejected when the EventEmitter emits 'error'. The Promise will resolve with an array of all the arguments emitted to the given event. This method is intentionally generic and works with the web platform EventTarget interface, which has no special 'error' event semantics and does not listen to the 'error' event. Basic example: ````javascript var emitter= new EventEmitter2(); EventEmitter2.once(emitter, 'event', { timeout: 0, Promise: Promise, // a custom Promise constructor overload: false // overload promise cancellation api if exists with library implementation }).then(function(data){ console.log(data); // [1, 2, 3] }); emitter.emit('event', 1, 2, 3); ```` With timeout option: ````javascript EventEmitter2.once(emitter, 'event', { timeout: 1000 }).then(null, function(err){ console.log(err); // Error: timeout }); ```` The library promise cancellation API: ````javascript promise= EventEmitter2.once(emitter, 'event'); // notice: the cancel method exists only in the first promise chain promise.then(null, function(err){ console.log(err); // Error: canceled }); promise.cancel(); ```` Using the custom Promise class (**[bluebird.js](https://www.npmjs.com/package/bluebird)**): ````javascript var BBPromise = require("bluebird"); EventEmitter2.once(emitter, 'event', { Promise: BBPromise }).then(function(data){ console.log(data); // [4, 5, 6] }); emitter.emit('event', 4, 5, 6); ```` ````javascript var BBPromise = require("bluebird"); BBPromise.config({ // if false or options.overload enabled, the library cancellation API will be used cancellation: true }); var promise= EventEmitter2.once(emitter, 'event', { Promise: BBPromise, overload: false // use bluebird cancellation API }).then(function(data){ // notice: never executed due to BlueBird cancellation logic }, function(err){ // notice: never executed due to BlueBird cancellation logic }); promise.cancel(); emitter.emit('event', 'never handled'); ```` ### EventEmitter2.defaultMaxListeners Sets default max listeners count globally for all instances, including those created before the change is made. EventEmitter2-6.4.7/bower.json000066400000000000000000000003061427200005100162240ustar00rootroot00000000000000{ "name": "eventemitter2", "version": "5.0.1", "description": "A Node.js event emitter implementation with namespaces, wildcards, TTL and browser support.", "main": "lib/eventemitter2.js" } EventEmitter2-6.4.7/component.json000066400000000000000000000005331427200005100171120ustar00rootroot00000000000000{ "name": "eventemitter2", "version": "5.0.1", "description": "A Node.js event emitter implementation with namespaces, wildcards, TTL and browser support.", "keywords": [ "event", "events", "emitter", "eventemitter" ], "main": "lib/eventemitter2.js", "scripts": [ "lib/eventemitter2.js" ], "license": "MIT" } EventEmitter2-6.4.7/eventemitter2.d.ts000066400000000000000000000122751427200005100176120ustar00rootroot00000000000000export type event = (symbol|string); export type eventNS = string|event[]; export interface ConstructorOptions { /** * @default false * @description set this to `true` to use wildcards. */ wildcard?: boolean, /** * @default '.' * @description the delimiter used to segment namespaces. */ delimiter?: string, /** * @default false * @description set this to `true` if you want to emit the newListener events. */ newListener?: boolean, /** * @default false * @description set this to `true` if you want to emit the removeListener events. */ removeListener?: boolean, /** * @default 10 * @description the maximum amount of listeners that can be assigned to an event. */ maxListeners?: number /** * @default false * @description show event name in memory leak message when more than maximum amount of listeners is assigned, default false */ verboseMemoryLeak?: boolean /** * @default false * @description disable throwing uncaughtException if an error event is emitted and it has no listeners */ ignoreErrors?: boolean } export interface ListenerFn { (...values: any[]): void; } export interface EventAndListener { (event: string | string[], ...values: any[]): void; } export interface WaitForFilter { (...values: any[]): boolean } export interface WaitForOptions { /** * @default 0 */ timeout: number, /** * @default null */ filter: WaitForFilter, /** * @default false */ handleError: boolean, /** * @default Promise */ Promise: Function, /** * @default false */ overload: boolean } export interface CancelablePromise extends Promise{ cancel(reason: string): undefined } export interface OnceOptions { /** * @default 0 */ timeout: number, /** * @default Promise */ Promise: Function, /** * @default false */ overload: boolean } export interface ListenToOptions { on?: { (event: event | eventNS, handler: ListenerFn): void }, off?: { (event: event | eventNS, handler: ListenerFn): void }, reducers: Function | Object } export interface GeneralEventEmitter{ addEventListener(event: event, handler: ListenerFn): this, removeEventListener(event: event, handler: ListenerFn): this, addListener?(event: event, handler: ListenerFn): this, removeListener?(event: event, handler: ListenerFn): this, on?(event: event, handler: ListenerFn): this, off?(event: event, handler: ListenerFn): this } export interface OnOptions { async?: boolean, promisify?: boolean, nextTick?: boolean, objectify?: boolean } export interface Listener { emitter: EventEmitter2; event: event|eventNS; listener: ListenerFn; off(): this; } export declare class EventEmitter2 { constructor(options?: ConstructorOptions) emit(event: event | eventNS, ...values: any[]): boolean; emitAsync(event: event | eventNS, ...values: any[]): Promise; addListener(event: event | eventNS, listener: ListenerFn): this|Listener; on(event: event | eventNS, listener: ListenerFn, options?: boolean|OnOptions): this|Listener; prependListener(event: event | eventNS, listener: ListenerFn, options?: boolean|OnOptions): this|Listener; once(event: event | eventNS, listener: ListenerFn, options?: true|OnOptions): this|Listener; prependOnceListener(event: event | eventNS, listener: ListenerFn, options?: boolean|OnOptions): this|Listener; many(event: event | eventNS, timesToListen: number, listener: ListenerFn, options?: boolean|OnOptions): this|Listener; prependMany(event: event | eventNS, timesToListen: number, listener: ListenerFn, options?: boolean|OnOptions): this|Listener; onAny(listener: EventAndListener): this; prependAny(listener: EventAndListener): this; offAny(listener: ListenerFn): this; removeListener(event: event | eventNS, listener: ListenerFn): this; off(event: event | eventNS, listener: ListenerFn): this; removeAllListeners(event?: event | eventNS): this; setMaxListeners(n: number): void; getMaxListeners(): number; eventNames(nsAsArray?: boolean): (event|eventNS)[]; listenerCount(event?: event | eventNS): number listeners(event?: event | eventNS): ListenerFn[] listenersAny(): ListenerFn[] waitFor(event: event | eventNS, timeout?: number): CancelablePromise waitFor(event: event | eventNS, filter?: WaitForFilter): CancelablePromise waitFor(event: event | eventNS, options?: WaitForOptions): CancelablePromise listenTo(target: GeneralEventEmitter, events: event | eventNS, options?: ListenToOptions): this; listenTo(target: GeneralEventEmitter, events: event[], options?: ListenToOptions): this; listenTo(target: GeneralEventEmitter, events: Object, options?: ListenToOptions): this; stopListeningTo(target?: GeneralEventEmitter, event?: event | eventNS): Boolean; hasListeners(event?: String): Boolean static once(emitter: EventEmitter2, event: event | eventNS, options?: OnceOptions): CancelablePromise; static defaultMaxListeners: number; } export default EventEmitter2; EventEmitter2-6.4.7/index.js000066400000000000000000000000611427200005100156560ustar00rootroot00000000000000module.exports = require('./lib/eventemitter2'); EventEmitter2-6.4.7/lib/000077500000000000000000000000001427200005100147625ustar00rootroot00000000000000EventEmitter2-6.4.7/lib/eventemitter2.js000066400000000000000000001266571427200005100201360ustar00rootroot00000000000000/*! * EventEmitter2 * https://github.com/hij1nx/EventEmitter2 * * Copyright (c) 2013 hij1nx * Licensed under the MIT license. */ ;!function(undefined) { var hasOwnProperty= Object.hasOwnProperty; var isArray = Array.isArray ? Array.isArray : function _isArray(obj) { return Object.prototype.toString.call(obj) === "[object Array]"; }; var defaultMaxListeners = 10; var nextTickSupported= typeof process=='object' && typeof process.nextTick=='function'; var symbolsSupported= typeof Symbol==='function'; var reflectSupported= typeof Reflect === 'object'; var setImmediateSupported= typeof setImmediate === 'function'; var _setImmediate= setImmediateSupported ? setImmediate : setTimeout; var ownKeys= symbolsSupported? (reflectSupported && typeof Reflect.ownKeys==='function'? Reflect.ownKeys : function(obj){ var arr= Object.getOwnPropertyNames(obj); arr.push.apply(arr, Object.getOwnPropertySymbols(obj)); return arr; }) : Object.keys; function init() { this._events = {}; if (this._conf) { configure.call(this, this._conf); } } function configure(conf) { if (conf) { this._conf = conf; conf.delimiter && (this.delimiter = conf.delimiter); if(conf.maxListeners!==undefined){ this._maxListeners= conf.maxListeners; } conf.wildcard && (this.wildcard = conf.wildcard); conf.newListener && (this._newListener = conf.newListener); conf.removeListener && (this._removeListener = conf.removeListener); conf.verboseMemoryLeak && (this.verboseMemoryLeak = conf.verboseMemoryLeak); conf.ignoreErrors && (this.ignoreErrors = conf.ignoreErrors); if (this.wildcard) { this.listenerTree = {}; } } } function logPossibleMemoryLeak(count, eventName) { var errorMsg = '(node) warning: possible EventEmitter memory ' + 'leak detected. ' + count + ' listeners added. ' + 'Use emitter.setMaxListeners() to increase limit.'; if(this.verboseMemoryLeak){ errorMsg += ' Event name: ' + eventName + '.'; } if(typeof process !== 'undefined' && process.emitWarning){ var e = new Error(errorMsg); e.name = 'MaxListenersExceededWarning'; e.emitter = this; e.count = count; process.emitWarning(e); } else { console.error(errorMsg); if (console.trace){ console.trace(); } } } var toArray = function (a, b, c) { var n = arguments.length; switch (n) { case 0: return []; case 1: return [a]; case 2: return [a, b]; case 3: return [a, b, c]; default: var arr = new Array(n); while (n--) { arr[n] = arguments[n]; } return arr; } }; function toObject(keys, values) { var obj = {}; var key; var len = keys.length; var valuesCount = values ? values.length : 0; for (var i = 0; i < len; i++) { key = keys[i]; obj[key] = i < valuesCount ? values[i] : undefined; } return obj; } function TargetObserver(emitter, target, options) { this._emitter = emitter; this._target = target; this._listeners = {}; this._listenersCount = 0; var on, off; if (options.on || options.off) { on = options.on; off = options.off; } if (target.addEventListener) { on = target.addEventListener; off = target.removeEventListener; } else if (target.addListener) { on = target.addListener; off = target.removeListener; } else if (target.on) { on = target.on; off = target.off; } if (!on && !off) { throw Error('target does not implement any known event API'); } if (typeof on !== 'function') { throw TypeError('on method must be a function'); } if (typeof off !== 'function') { throw TypeError('off method must be a function'); } this._on = on; this._off = off; var _observers= emitter._observers; if(_observers){ _observers.push(this); }else{ emitter._observers= [this]; } } Object.assign(TargetObserver.prototype, { subscribe: function(event, localEvent, reducer){ var observer= this; var target= this._target; var emitter= this._emitter; var listeners= this._listeners; var handler= function(){ var args= toArray.apply(null, arguments); var eventObj= { data: args, name: localEvent, original: event }; if(reducer){ var result= reducer.call(target, eventObj); if(result!==false){ emitter.emit.apply(emitter, [eventObj.name].concat(args)) } return; } emitter.emit.apply(emitter, [localEvent].concat(args)); }; if(listeners[event]){ throw Error('Event \'' + event + '\' is already listening'); } this._listenersCount++; if(emitter._newListener && emitter._removeListener && !observer._onNewListener){ this._onNewListener = function (_event) { if (_event === localEvent && listeners[event] === null) { listeners[event] = handler; observer._on.call(target, event, handler); } }; emitter.on('newListener', this._onNewListener); this._onRemoveListener= function(_event){ if(_event === localEvent && !emitter.hasListeners(_event) && listeners[event]){ listeners[event]= null; observer._off.call(target, event, handler); } }; listeners[event]= null; emitter.on('removeListener', this._onRemoveListener); }else{ listeners[event]= handler; observer._on.call(target, event, handler); } }, unsubscribe: function(event){ var observer= this; var listeners= this._listeners; var emitter= this._emitter; var handler; var events; var off= this._off; var target= this._target; var i; if(event && typeof event!=='string'){ throw TypeError('event must be a string'); } function clearRefs(){ if(observer._onNewListener){ emitter.off('newListener', observer._onNewListener); emitter.off('removeListener', observer._onRemoveListener); observer._onNewListener= null; observer._onRemoveListener= null; } var index= findTargetIndex.call(emitter, observer); emitter._observers.splice(index, 1); } if(event){ handler= listeners[event]; if(!handler) return; off.call(target, event, handler); delete listeners[event]; if(!--this._listenersCount){ clearRefs(); } }else{ events= ownKeys(listeners); i= events.length; while(i-->0){ event= events[i]; off.call(target, event, listeners[event]); } this._listeners= {}; this._listenersCount= 0; clearRefs(); } } }); function resolveOptions(options, schema, reducers, allowUnknown) { var computedOptions = Object.assign({}, schema); if (!options) return computedOptions; if (typeof options !== 'object') { throw TypeError('options must be an object') } var keys = Object.keys(options); var length = keys.length; var option, value; var reducer; function reject(reason) { throw Error('Invalid "' + option + '" option value' + (reason ? '. Reason: ' + reason : '')) } for (var i = 0; i < length; i++) { option = keys[i]; if (!allowUnknown && !hasOwnProperty.call(schema, option)) { throw Error('Unknown "' + option + '" option'); } value = options[option]; if (value !== undefined) { reducer = reducers[option]; computedOptions[option] = reducer ? reducer(value, reject) : value; } } return computedOptions; } function constructorReducer(value, reject) { if (typeof value !== 'function' || !value.hasOwnProperty('prototype')) { reject('value must be a constructor'); } return value; } function makeTypeReducer(types) { var message= 'value must be type of ' + types.join('|'); var len= types.length; var firstType= types[0]; var secondType= types[1]; if (len === 1) { return function (v, reject) { if (typeof v === firstType) { return v; } reject(message); } } if (len === 2) { return function (v, reject) { var kind= typeof v; if (kind === firstType || kind === secondType) return v; reject(message); } } return function (v, reject) { var kind = typeof v; var i = len; while (i-- > 0) { if (kind === types[i]) return v; } reject(message); } } var functionReducer= makeTypeReducer(['function']); var objectFunctionReducer= makeTypeReducer(['object', 'function']); function makeCancelablePromise(Promise, executor, options) { var isCancelable; var callbacks; var timer= 0; var subscriptionClosed; var promise = new Promise(function (resolve, reject, onCancel) { options= resolveOptions(options, { timeout: 0, overload: false }, { timeout: function(value, reject){ value*= 1; if (typeof value !== 'number' || value < 0 || !Number.isFinite(value)) { reject('timeout must be a positive number'); } return value; } }); isCancelable = !options.overload && typeof Promise.prototype.cancel === 'function' && typeof onCancel === 'function'; function cleanup() { if (callbacks) { callbacks = null; } if (timer) { clearTimeout(timer); timer = 0; } } var _resolve= function(value){ cleanup(); resolve(value); }; var _reject= function(err){ cleanup(); reject(err); }; if (isCancelable) { executor(_resolve, _reject, onCancel); } else { callbacks = [function(reason){ _reject(reason || Error('canceled')); }]; executor(_resolve, _reject, function (cb) { if (subscriptionClosed) { throw Error('Unable to subscribe on cancel event asynchronously') } if (typeof cb !== 'function') { throw TypeError('onCancel callback must be a function'); } callbacks.push(cb); }); subscriptionClosed= true; } if (options.timeout > 0) { timer= setTimeout(function(){ var reason= Error('timeout'); reason.code = 'ETIMEDOUT' timer= 0; promise.cancel(reason); reject(reason); }, options.timeout); } }); if (!isCancelable) { promise.cancel = function (reason) { if (!callbacks) { return; } var length = callbacks.length; for (var i = 1; i < length; i++) { callbacks[i](reason); } // internal callback to reject the promise callbacks[0](reason); callbacks = null; }; } return promise; } function findTargetIndex(observer) { var observers = this._observers; if(!observers){ return -1; } var len = observers.length; for (var i = 0; i < len; i++) { if (observers[i]._target === observer) return i; } return -1; } // Attention, function return type now is array, always ! // It has zero elements if no any matches found and one or more // elements (leafs) if there are matches // function searchListenerTree(handlers, type, tree, i, typeLength) { if (!tree) { return null; } if (i === 0) { var kind = typeof type; if (kind === 'string') { var ns, n, l = 0, j = 0, delimiter = this.delimiter, dl = delimiter.length; if ((n = type.indexOf(delimiter)) !== -1) { ns = new Array(5); do { ns[l++] = type.slice(j, n); j = n + dl; } while ((n = type.indexOf(delimiter, j)) !== -1); ns[l++] = type.slice(j); type = ns; typeLength = l; } else { type = [type]; typeLength = 1; } } else if (kind === 'object') { typeLength = type.length; } else { type = [type]; typeLength = 1; } } var listeners= null, branch, xTree, xxTree, isolatedBranch, endReached, currentType = type[i], nextType = type[i + 1], branches, _listeners; if (i === typeLength) { // // If at the end of the event(s) list and the tree has listeners // invoke those listeners. // if(tree._listeners) { if (typeof tree._listeners === 'function') { handlers && handlers.push(tree._listeners); listeners = [tree]; } else { handlers && handlers.push.apply(handlers, tree._listeners); listeners = [tree]; } } } else { if (currentType === '*') { // // If the event emitted is '*' at this part // or there is a concrete match at this patch // branches = ownKeys(tree); n = branches.length; while (n-- > 0) { branch = branches[n]; if (branch !== '_listeners') { _listeners = searchListenerTree(handlers, type, tree[branch], i + 1, typeLength); if (_listeners) { if (listeners) { listeners.push.apply(listeners, _listeners); } else { listeners = _listeners; } } } } return listeners; } else if (currentType === '**') { endReached = (i + 1 === typeLength || (i + 2 === typeLength && nextType === '*')); if (endReached && tree._listeners) { // The next element has a _listeners, add it to the handlers. listeners = searchListenerTree(handlers, type, tree, typeLength, typeLength); } branches = ownKeys(tree); n = branches.length; while (n-- > 0) { branch = branches[n]; if (branch !== '_listeners') { if (branch === '*' || branch === '**') { if (tree[branch]._listeners && !endReached) { _listeners = searchListenerTree(handlers, type, tree[branch], typeLength, typeLength); if (_listeners) { if (listeners) { listeners.push.apply(listeners, _listeners); } else { listeners = _listeners; } } } _listeners = searchListenerTree(handlers, type, tree[branch], i, typeLength); } else if (branch === nextType) { _listeners = searchListenerTree(handlers, type, tree[branch], i + 2, typeLength); } else { // No match on this one, shift into the tree but not in the type array. _listeners = searchListenerTree(handlers, type, tree[branch], i, typeLength); } if (_listeners) { if (listeners) { listeners.push.apply(listeners, _listeners); } else { listeners = _listeners; } } } } return listeners; } else if (tree[currentType]) { listeners = searchListenerTree(handlers, type, tree[currentType], i + 1, typeLength); } } xTree = tree['*']; if (xTree) { // // If the listener tree will allow any match for this part, // then recursively explore all branches of the tree // searchListenerTree(handlers, type, xTree, i + 1, typeLength); } xxTree = tree['**']; if (xxTree) { if (i < typeLength) { if (xxTree._listeners) { // If we have a listener on a '**', it will catch all, so add its handler. searchListenerTree(handlers, type, xxTree, typeLength, typeLength); } // Build arrays of matching next branches and others. branches= ownKeys(xxTree); n= branches.length; while(n-->0){ branch= branches[n]; if (branch !== '_listeners') { if (branch === nextType) { // We know the next element will match, so jump twice. searchListenerTree(handlers, type, xxTree[branch], i + 2, typeLength); } else if (branch === currentType) { // Current node matches, move into the tree. searchListenerTree(handlers, type, xxTree[branch], i + 1, typeLength); } else { isolatedBranch = {}; isolatedBranch[branch] = xxTree[branch]; searchListenerTree(handlers, type, {'**': isolatedBranch}, i + 1, typeLength); } } } } else if (xxTree._listeners) { // We have reached the end and still on a '**' searchListenerTree(handlers, type, xxTree, typeLength, typeLength); } else if (xxTree['*'] && xxTree['*']._listeners) { searchListenerTree(handlers, type, xxTree['*'], typeLength, typeLength); } } return listeners; } function growListenerTree(type, listener, prepend) { var len = 0, j = 0, i, delimiter = this.delimiter, dl= delimiter.length, ns; if(typeof type==='string') { if ((i = type.indexOf(delimiter)) !== -1) { ns = new Array(5); do { ns[len++] = type.slice(j, i); j = i + dl; } while ((i = type.indexOf(delimiter, j)) !== -1); ns[len++] = type.slice(j); }else{ ns= [type]; len= 1; } }else{ ns= type; len= type.length; } // // Looks for two consecutive '**', if so, don't add the event at all. // if (len > 1) { for (i = 0; i + 1 < len; i++) { if (ns[i] === '**' && ns[i + 1] === '**') { return; } } } var tree = this.listenerTree, name; for (i = 0; i < len; i++) { name = ns[i]; tree = tree[name] || (tree[name] = {}); if (i === len - 1) { if (!tree._listeners) { tree._listeners = listener; } else { if (typeof tree._listeners === 'function') { tree._listeners = [tree._listeners]; } if (prepend) { tree._listeners.unshift(listener); } else { tree._listeners.push(listener); } if ( !tree._listeners.warned && this._maxListeners > 0 && tree._listeners.length > this._maxListeners ) { tree._listeners.warned = true; logPossibleMemoryLeak.call(this, tree._listeners.length, name); } } return true; } } return true; } function collectTreeEvents(tree, events, root, asArray){ var branches= ownKeys(tree); var i= branches.length; var branch, branchName, path; var hasListeners= tree['_listeners']; var isArrayPath; while(i-->0){ branchName= branches[i]; branch= tree[branchName]; if(branchName==='_listeners'){ path= root; }else { path = root ? root.concat(branchName) : [branchName]; } isArrayPath= asArray || typeof branchName==='symbol'; hasListeners && events.push(isArrayPath? path : path.join(this.delimiter)); if(typeof branch==='object'){ collectTreeEvents.call(this, branch, events, path, isArrayPath); } } return events; } function recursivelyGarbageCollect(root) { var keys = ownKeys(root); var i= keys.length; var obj, key, flag; while(i-->0){ key = keys[i]; obj = root[key]; if(obj){ flag= true; if(key !== '_listeners' && !recursivelyGarbageCollect(obj)){ delete root[key]; } } } return flag; } function Listener(emitter, event, listener){ this.emitter= emitter; this.event= event; this.listener= listener; } Listener.prototype.off= function(){ this.emitter.off(this.event, this.listener); return this; }; function setupListener(event, listener, options){ if (options === true) { promisify = true; } else if (options === false) { async = true; } else { if (!options || typeof options !== 'object') { throw TypeError('options should be an object or true'); } var async = options.async; var promisify = options.promisify; var nextTick = options.nextTick; var objectify = options.objectify; } if (async || nextTick || promisify) { var _listener = listener; var _origin = listener._origin || listener; if (nextTick && !nextTickSupported) { throw Error('process.nextTick is not supported'); } if (promisify === undefined) { promisify = listener.constructor.name === 'AsyncFunction'; } listener = function () { var args = arguments; var context = this; var event = this.event; return promisify ? (nextTick ? Promise.resolve() : new Promise(function (resolve) { _setImmediate(resolve); }).then(function () { context.event = event; return _listener.apply(context, args) })) : (nextTick ? process.nextTick : _setImmediate)(function () { context.event = event; _listener.apply(context, args) }); }; listener._async = true; listener._origin = _origin; } return [listener, objectify? new Listener(this, event, listener): this]; } function EventEmitter(conf) { this._events = {}; this._newListener = false; this._removeListener = false; this.verboseMemoryLeak = false; configure.call(this, conf); } EventEmitter.EventEmitter2 = EventEmitter; // backwards compatibility for exporting EventEmitter property EventEmitter.prototype.listenTo= function(target, events, options){ if(typeof target!=='object'){ throw TypeError('target musts be an object'); } var emitter= this; options = resolveOptions(options, { on: undefined, off: undefined, reducers: undefined }, { on: functionReducer, off: functionReducer, reducers: objectFunctionReducer }); function listen(events){ if(typeof events!=='object'){ throw TypeError('events must be an object'); } var reducers= options.reducers; var index= findTargetIndex.call(emitter, target); var observer; if(index===-1){ observer= new TargetObserver(emitter, target, options); }else{ observer= emitter._observers[index]; } var keys= ownKeys(events); var len= keys.length; var event; var isSingleReducer= typeof reducers==='function'; for(var i=0; i 0) { observer = observers[i]; if (!target || observer._target === target) { observer.unsubscribe(event); matched= true; } } return matched; }; // By default EventEmitters will print a warning if more than // 10 listeners are added to it. This is a useful default which // helps finding memory leaks. // // Obviously not all Emitters should be limited to 10. This function allows // that to be increased. Set to zero for unlimited. EventEmitter.prototype.delimiter = '.'; EventEmitter.prototype.setMaxListeners = function(n) { if (n !== undefined) { this._maxListeners = n; if (!this._conf) this._conf = {}; this._conf.maxListeners = n; } }; EventEmitter.prototype.getMaxListeners = function() { return this._maxListeners; }; EventEmitter.prototype.event = ''; EventEmitter.prototype.once = function(event, fn, options) { return this._once(event, fn, false, options); }; EventEmitter.prototype.prependOnceListener = function(event, fn, options) { return this._once(event, fn, true, options); }; EventEmitter.prototype._once = function(event, fn, prepend, options) { return this._many(event, 1, fn, prepend, options); }; EventEmitter.prototype.many = function(event, ttl, fn, options) { return this._many(event, ttl, fn, false, options); }; EventEmitter.prototype.prependMany = function(event, ttl, fn, options) { return this._many(event, ttl, fn, true, options); }; EventEmitter.prototype._many = function(event, ttl, fn, prepend, options) { var self = this; if (typeof fn !== 'function') { throw new Error('many only accepts instances of Function'); } function listener() { if (--ttl === 0) { self.off(event, listener); } return fn.apply(this, arguments); } listener._origin = fn; return this._on(event, listener, prepend, options); }; EventEmitter.prototype.emit = function() { if (!this._events && !this._all) { return false; } this._events || init.call(this); var type = arguments[0], ns, wildcard= this.wildcard; var args,l,i,j, containsSymbol; if (type === 'newListener' && !this._newListener) { if (!this._events.newListener) { return false; } } if (wildcard) { ns= type; if(type!=='newListener' && type!=='removeListener'){ if (typeof type === 'object') { l = type.length; if (symbolsSupported) { for (i = 0; i < l; i++) { if (typeof type[i] === 'symbol') { containsSymbol = true; break; } } } if (!containsSymbol) { type = type.join(this.delimiter); } } } } var al = arguments.length; var handler; if (this._all && this._all.length) { handler = this._all.slice(); for (i = 0, l = handler.length; i < l; i++) { this.event = type; switch (al) { case 1: handler[i].call(this, type); break; case 2: handler[i].call(this, type, arguments[1]); break; case 3: handler[i].call(this, type, arguments[1], arguments[2]); break; default: handler[i].apply(this, arguments); } } } if (wildcard) { handler = []; searchListenerTree.call(this, handler, ns, this.listenerTree, 0, l); } else { handler = this._events[type]; if (typeof handler === 'function') { this.event = type; switch (al) { case 1: handler.call(this); break; case 2: handler.call(this, arguments[1]); break; case 3: handler.call(this, arguments[1], arguments[2]); break; default: args = new Array(al - 1); for (j = 1; j < al; j++) args[j - 1] = arguments[j]; handler.apply(this, args); } return true; } else if (handler) { // need to make copy of handlers because list can change in the middle // of emit call handler = handler.slice(); } } if (handler && handler.length) { if (al > 3) { args = new Array(al - 1); for (j = 1; j < al; j++) args[j - 1] = arguments[j]; } for (i = 0, l = handler.length; i < l; i++) { this.event = type; switch (al) { case 1: handler[i].call(this); break; case 2: handler[i].call(this, arguments[1]); break; case 3: handler[i].call(this, arguments[1], arguments[2]); break; default: handler[i].apply(this, args); } } return true; } else if (!this.ignoreErrors && !this._all && type === 'error') { if (arguments[1] instanceof Error) { throw arguments[1]; // Unhandled 'error' event } else { throw new Error("Uncaught, unspecified 'error' event."); } } return !!this._all; }; EventEmitter.prototype.emitAsync = function() { if (!this._events && !this._all) { return false; } this._events || init.call(this); var type = arguments[0], wildcard= this.wildcard, ns, containsSymbol; var args,l,i,j; if (type === 'newListener' && !this._newListener) { if (!this._events.newListener) { return Promise.resolve([false]); } } if (wildcard) { ns= type; if(type!=='newListener' && type!=='removeListener'){ if (typeof type === 'object') { l = type.length; if (symbolsSupported) { for (i = 0; i < l; i++) { if (typeof type[i] === 'symbol') { containsSymbol = true; break; } } } if (!containsSymbol) { type = type.join(this.delimiter); } } } } var promises= []; var al = arguments.length; var handler; if (this._all) { for (i = 0, l = this._all.length; i < l; i++) { this.event = type; switch (al) { case 1: promises.push(this._all[i].call(this, type)); break; case 2: promises.push(this._all[i].call(this, type, arguments[1])); break; case 3: promises.push(this._all[i].call(this, type, arguments[1], arguments[2])); break; default: promises.push(this._all[i].apply(this, arguments)); } } } if (wildcard) { handler = []; searchListenerTree.call(this, handler, ns, this.listenerTree, 0); } else { handler = this._events[type]; } if (typeof handler === 'function') { this.event = type; switch (al) { case 1: promises.push(handler.call(this)); break; case 2: promises.push(handler.call(this, arguments[1])); break; case 3: promises.push(handler.call(this, arguments[1], arguments[2])); break; default: args = new Array(al - 1); for (j = 1; j < al; j++) args[j - 1] = arguments[j]; promises.push(handler.apply(this, args)); } } else if (handler && handler.length) { handler = handler.slice(); if (al > 3) { args = new Array(al - 1); for (j = 1; j < al; j++) args[j - 1] = arguments[j]; } for (i = 0, l = handler.length; i < l; i++) { this.event = type; switch (al) { case 1: promises.push(handler[i].call(this)); break; case 2: promises.push(handler[i].call(this, arguments[1])); break; case 3: promises.push(handler[i].call(this, arguments[1], arguments[2])); break; default: promises.push(handler[i].apply(this, args)); } } } else if (!this.ignoreErrors && !this._all && type === 'error') { if (arguments[1] instanceof Error) { return Promise.reject(arguments[1]); // Unhandled 'error' event } else { return Promise.reject("Uncaught, unspecified 'error' event."); } } return Promise.all(promises); }; EventEmitter.prototype.on = function(type, listener, options) { return this._on(type, listener, false, options); }; EventEmitter.prototype.prependListener = function(type, listener, options) { return this._on(type, listener, true, options); }; EventEmitter.prototype.onAny = function(fn) { return this._onAny(fn, false); }; EventEmitter.prototype.prependAny = function(fn) { return this._onAny(fn, true); }; EventEmitter.prototype.addListener = EventEmitter.prototype.on; EventEmitter.prototype._onAny = function(fn, prepend){ if (typeof fn !== 'function') { throw new Error('onAny only accepts instances of Function'); } if (!this._all) { this._all = []; } // Add the function to the event listener collection. if(prepend){ this._all.unshift(fn); }else{ this._all.push(fn); } return this; }; EventEmitter.prototype._on = function(type, listener, prepend, options) { if (typeof type === 'function') { this._onAny(type, listener); return this; } if (typeof listener !== 'function') { throw new Error('on only accepts instances of Function'); } this._events || init.call(this); var returnValue= this, temp; if (options !== undefined) { temp = setupListener.call(this, type, listener, options); listener = temp[0]; returnValue = temp[1]; } // To avoid recursion in the case that type == "newListeners"! Before // adding it to the listeners, first emit "newListeners". if (this._newListener) { this.emit('newListener', type, listener); } if (this.wildcard) { growListenerTree.call(this, type, listener, prepend); return returnValue; } if (!this._events[type]) { // Optimize the case of one listener. Don't need the extra array object. this._events[type] = listener; } else { if (typeof this._events[type] === 'function') { // Change to array. this._events[type] = [this._events[type]]; } // If we've already got an array, just add if(prepend){ this._events[type].unshift(listener); }else{ this._events[type].push(listener); } // Check for listener leak if ( !this._events[type].warned && this._maxListeners > 0 && this._events[type].length > this._maxListeners ) { this._events[type].warned = true; logPossibleMemoryLeak.call(this, this._events[type].length, type); } } return returnValue; }; EventEmitter.prototype.off = function(type, listener) { if (typeof listener !== 'function') { throw new Error('removeListener only takes instances of Function'); } var handlers,leafs=[]; if(this.wildcard) { var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0); if(!leafs) return this; } else { // does not use listeners(), so no side effect of creating _events[type] if (!this._events[type]) return this; handlers = this._events[type]; leafs.push({_listeners:handlers}); } for (var iLeaf=0; iLeaf 0) { fns = this._all; for(i = 0, l = fns.length; i < l; i++) { if(fn === fns[i]) { fns.splice(i, 1); if (this._removeListener) this.emit("removeListenerAny", fn); return this; } } } else { fns = this._all; if (this._removeListener) { for(i = 0, l = fns.length; i < l; i++) this.emit("removeListenerAny", fns[i]); } this._all = []; } return this; }; EventEmitter.prototype.removeListener = EventEmitter.prototype.off; EventEmitter.prototype.removeAllListeners = function (type) { if (type === undefined) { !this._events || init.call(this); return this; } if (this.wildcard) { var leafs = searchListenerTree.call(this, null, type, this.listenerTree, 0), leaf, i; if (!leafs) return this; for (i = 0; i < leafs.length; i++) { leaf = leafs[i]; leaf._listeners = null; } this.listenerTree && recursivelyGarbageCollect(this.listenerTree); } else if (this._events) { this._events[type] = null; } return this; }; EventEmitter.prototype.listeners = function (type) { var _events = this._events; var keys, listeners, allListeners; var i; var listenerTree; if (type === undefined) { if (this.wildcard) { throw Error('event name required for wildcard emitter'); } if (!_events) { return []; } keys = ownKeys(_events); i = keys.length; allListeners = []; while (i-- > 0) { listeners = _events[keys[i]]; if (typeof listeners === 'function') { allListeners.push(listeners); } else { allListeners.push.apply(allListeners, listeners); } } return allListeners; } else { if (this.wildcard) { listenerTree= this.listenerTree; if(!listenerTree) return []; var handlers = []; var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); searchListenerTree.call(this, handlers, ns, listenerTree, 0); return handlers; } if (!_events) { return []; } listeners = _events[type]; if (!listeners) { return []; } return typeof listeners === 'function' ? [listeners] : listeners; } }; EventEmitter.prototype.eventNames = function(nsAsArray){ var _events= this._events; return this.wildcard? collectTreeEvents.call(this, this.listenerTree, [], null, nsAsArray) : (_events? ownKeys(_events) : []); }; EventEmitter.prototype.listenerCount = function(type) { return this.listeners(type).length; }; EventEmitter.prototype.hasListeners = function (type) { if (this.wildcard) { var handlers = []; var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); searchListenerTree.call(this, handlers, ns, this.listenerTree, 0); return handlers.length > 0; } var _events = this._events; var _all = this._all; return !!(_all && _all.length || _events && (type === undefined ? ownKeys(_events).length : _events[type])); }; EventEmitter.prototype.listenersAny = function() { if(this._all) { return this._all; } else { return []; } }; EventEmitter.prototype.waitFor = function (event, options) { var self = this; var type = typeof options; if (type === 'number') { options = {timeout: options}; } else if (type === 'function') { options = {filter: options}; } options= resolveOptions(options, { timeout: 0, filter: undefined, handleError: false, Promise: Promise, overload: false }, { filter: functionReducer, Promise: constructorReducer }); return makeCancelablePromise(options.Promise, function (resolve, reject, onCancel) { function listener() { var filter= options.filter; if (filter && !filter.apply(self, arguments)) { return; } self.off(event, listener); if (options.handleError) { var err = arguments[0]; err ? reject(err) : resolve(toArray.apply(null, arguments).slice(1)); } else { resolve(toArray.apply(null, arguments)); } } onCancel(function(){ self.off(event, listener); }); self._on(event, listener, false); }, { timeout: options.timeout, overload: options.overload }) }; function once(emitter, name, options) { options= resolveOptions(options, { Promise: Promise, timeout: 0, overload: false }, { Promise: constructorReducer }); var _Promise= options.Promise; return makeCancelablePromise(_Promise, function(resolve, reject, onCancel){ var handler; if (typeof emitter.addEventListener === 'function') { handler= function () { resolve(toArray.apply(null, arguments)); }; onCancel(function(){ emitter.removeEventListener(name, handler); }); emitter.addEventListener( name, handler, {once: true} ); return; } var eventListener = function(){ errorListener && emitter.removeListener('error', errorListener); resolve(toArray.apply(null, arguments)); }; var errorListener; if (name !== 'error') { errorListener = function (err){ emitter.removeListener(name, eventListener); reject(err); }; emitter.once('error', errorListener); } onCancel(function(){ errorListener && emitter.removeListener('error', errorListener); emitter.removeListener(name, eventListener); }); emitter.once(name, eventListener); }, { timeout: options.timeout, overload: options.overload }); } var prototype= EventEmitter.prototype; Object.defineProperties(EventEmitter, { defaultMaxListeners: { get: function () { return prototype._maxListeners; }, set: function (n) { if (typeof n !== 'number' || n < 0 || Number.isNaN(n)) { throw TypeError('n must be a non-negative number') } prototype._maxListeners = n; }, enumerable: true }, once: { value: once, writable: true, configurable: true } }); Object.defineProperties(prototype, { _maxListeners: { value: defaultMaxListeners, writable: true, configurable: true }, _observers: {value: null, writable: true, configurable: true} }); if (typeof define === 'function' && define.amd) { // AMD. Register as an anonymous module. define(function() { return EventEmitter; }); } else if (typeof exports === 'object') { // CommonJS module.exports = EventEmitter; } else { // global for any kind of environment. var _global= new Function('','return this')(); _global.EventEmitter2 = EventEmitter; } }(); EventEmitter2-6.4.7/package.json000066400000000000000000000042631427200005100165070ustar00rootroot00000000000000{ "name": "eventemitter2", "version": "6.4.7", "description": "A feature-rich Node.js event emitter implementation with namespaces, wildcards, TTL, async listeners and browser/worker support.", "keywords": [ "event", "events", "emitter", "eventemitter", "addEventListener", "addListener", "pub/sub", "emit", "emits", "on", "once", "publish", "subscribe" ], "author": "hij1nx http://twitter.com/hij1nx", "contributors": [ "Eric Elliott", "Charlie Robbins http://twitter.com/indexzero", "Jameson Lee http://twitter.com/Jamesonjlee", "Jeroen van Duffelen http://www.twitter.com/jvduf", "Fedor Indutny http://www.twitter.com/indutny" ], "license": "MIT", "repository": "git://github.com/hij1nx/EventEmitter2.git", "devDependencies": { "benchmark": "^2.1.4", "bluebird": "^3.7.2", "coveralls": "^3.0.11", "mocha": "^7.1.1", "nodeunit": "*", "nyc": "^15.0.0" }, "main": "./lib/eventemitter2.js", "scripts": { "test": "mocha ./test/loader.js --exit --timeout=3000", "test:legacy": "nodeunit test/simple/ test/wildcardEvents/", "test:coverage": "nyc --check-coverage npm run test", "coverage:report": "nyc report --reporter=html --reporter=text", "coveralls": "nyc report --reporter=text-lcov | coveralls", "benchmark": "node test/perf/benchmark.js", "prepublishOnly": "npm run test:coverage", "postversion": "git push && git push --tags" }, "files": [ "lib/eventemitter2.js", "index.js", "eventemitter2.d.ts" ], "typings": "./eventemitter2.d.ts", "typescript": { "definition": "./eventemitter2.d.ts" }, "nyc": { "lines": 80, "functions": 80, "branches": 75, "statements": 80, "watermarks": { "lines": [ 80, 95 ], "functions": [ 80, 95 ], "branches": [ 80, 95 ], "statements": [ 80, 95 ] }, "include": [ "lib/**/*.js" ], "reporter": [ "lcov", "text-summary" ] } } EventEmitter2-6.4.7/test/000077500000000000000000000000001427200005100151735ustar00rootroot00000000000000EventEmitter2-6.4.7/test/common.js000066400000000000000000000114151427200005100170230ustar00rootroot00000000000000// Copyright Joyent, Inc. and other Node contributors. // // 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. "use strict"; var path = require('path'); var assert = require('assert'); exports.testDir = path.dirname(__filename); exports.fixturesDir = path.join(exports.testDir, 'fixtures'); exports.libDir = path.join(exports.testDir, '../lib'); exports.tmpDir = path.join(exports.testDir, 'tmp'); exports.PORT = 12346; if (process.platform == 'win32') { exports.PIPE = '\\\\.\\pipe\\libuv-test'; } else { exports.PIPE = exports.tmpDir + '/test.sock'; } var util = require('util'); for (var i in util) exports[i] = util[i]; //for (var i in exports) global[i] = exports[i]; function protoCtrChain(o) { var result = []; for (; o; o = o.__proto__) { result.push(o.constructor); } return result.join(); } exports.indirectInstanceOf = function(obj, cls) { if (obj instanceof cls) { return true; } var clsChain = protoCtrChain(cls.prototype); var objChain = protoCtrChain(obj); return objChain.slice(-clsChain.length) === clsChain; }; // Turn this off if the test should not check for global leaks. exports.globalCheck = true; if (process.env.CHECK_GLOBAL_LEAKS) { process.on('exit', function() { if (!exports.globalCheck) return; var knownGlobals = [setTimeout, setInterval, clearTimeout, clearInterval, console, Buffer, process, global.ArrayBuffer!==undefined?ArrayBuffer:null, global.Int8Array!==undefined?Int8Array:null, global.Uint8Array!==undefined?Uint8Array:null, global.Int16Array!==undefined?Int16Array:null, global.Uint16Array!==undefined?Uint16Array:null, global.Int32Array!==undefined?Int32Array:null, global.Uint32Array!==undefined?Uint32Array:null, global.Float32Array!==undefined?Float32Array:null, global.Float64Array!==undefined?Float64Array:null, global.DataView!==undefined?DataView:null, global.Uint8ClampedArray!==undefined?Uint8ClampedArray:null, global ]; if (global.setImmediate) { knownGlobals.push(setImmediate, clearImmediate); } if (global.errno) { knownGlobals.push(errno); } if (global.gc) { knownGlobals.push(gc); } if (global.DTRACE_HTTP_SERVER_RESPONSE) { knownGlobals.push(DTRACE_HTTP_SERVER_RESPONSE); knownGlobals.push(DTRACE_HTTP_SERVER_REQUEST); knownGlobals.push(DTRACE_HTTP_CLIENT_RESPONSE); knownGlobals.push(DTRACE_HTTP_CLIENT_REQUEST); knownGlobals.push(DTRACE_NET_STREAM_END); knownGlobals.push(DTRACE_NET_SERVER_CONNECTION); } if(global.COUNTER_NET_SERVER_CONNECTION){ knownGlobals.push(COUNTER_NET_SERVER_CONNECTION); knownGlobals.push(COUNTER_NET_SERVER_CONNECTION_CLOSE); knownGlobals.push(COUNTER_HTTP_SERVER_REQUEST); knownGlobals.push(COUNTER_HTTP_SERVER_RESPONSE); knownGlobals.push(COUNTER_HTTP_CLIENT_REQUEST); knownGlobals.push(COUNTER_HTTP_CLIENT_RESPONSE); } for (var x in global) { var found = false; for (var y in knownGlobals) { if (global[x] === knownGlobals[y]) { found = true; break; } } if (!found) { console.error('Unknown global: %s', x); assert.ok(false, 'Unknown global founded'); } } }); } // This function allows one two run an HTTP test agaist both HTTPS and // normal HTTP modules. This ensures they fit the same API. exports.httpTest = function httpTest(cb) { }; EventEmitter2-6.4.7/test/loader.js000066400000000000000000000056231427200005100170050ustar00rootroot00000000000000const fs = require('fs'); const path = require('path'); const assert = require('assert'); function importTests(root, filter) { const tests = {}; function scanDir(currentDir, testEntry) { fs.readdirSync(currentDir).forEach(function (entry) { entry = path.resolve(currentDir, entry); const stats = fs.statSync(entry); const {name, ext} = path.parse(entry); const relativePath = path.relative(root, entry); if (filter && !filter(relativePath)) return; if (stats.isDirectory()) { return scanDir(entry, testEntry[name] || (testEntry[name] = {})); } ext === '.js' && (testEntry[name] = require(entry)); }); } scanDir(root, tests); function _import(tests) { Object.keys(tests).forEach(function (testName) { const test = tests[testName]; const type = typeof test; if (type === 'object') { if (!type) { return; } describe(testName, function () { _import(test); }) } else if (type === 'function') { const executor = function (done) { if (!done) { return test.call(this); } let count, expectedCount; function wrap(fn) { return function () { count++; return fn.apply(null, arguments); } } const testObj = Object.assign(function () { return done.apply(this, arguments); }, { done: function (err) { if (expectedCount !== undefined && count < expectedCount) { throw Error(`${count}/${expectedCount} assertions was done`); } err ? done(err) : done(); }, expect: function (count) { expectedCount = count; } }); Object.keys(assert).forEach(function(prop){ const value= assert[prop]; typeof value==='function' && (testObj[prop]= wrap(value)); }); return test.call(this, testObj); }; it(testName, test.length ? executor : function () { return executor.call(this, null); }) } else { throw TypeError('expected an object or function'); } }) } _import(tests); } importTests('./test', function (path) { return !~['common.js', 'perf', 'test-loader.js'].indexOf(path); }); EventEmitter2-6.4.7/test/perf/000077500000000000000000000000001427200005100161275ustar00rootroot00000000000000EventEmitter2-6.4.7/test/perf/benchmark.js000066400000000000000000000053361427200005100204260ustar00rootroot00000000000000var os= require('os'); var Benchmark = require('benchmark'); var suite = new Benchmark.Suite(); var EventEmitter = require('events').EventEmitter; var emitter = new EventEmitter; var EventEmitter2 = require('../../lib/eventemitter2').EventEmitter2; var emitter2 = new EventEmitter2; var wildcardEmitter = new EventEmitter2({ wildcard: true }); var wildcardEmitter2 = new EventEmitter2({ wildcard: true }); wildcardEmitter2.on('test2.foo', function () { 1==1; }); wildcardEmitter2.on('test2', function () { 1==1; }); var EventEmitterB = require('events').EventEmitter; var emitterB = new EventEmitterB; var EventEmitter3 = require('eventemitter3').EventEmitter; var emitter3 = new EventEmitter3; console.log('Platform: ' + [ process.platform, process.arch, Math.round((os.totalmem() / (1024 * 1024))) + 'MB' ].join(', ')); console.log('Node version: ' + process.version); var cpus= {}; os.cpus().forEach(function(cpu){ var id= [cpu.model.trim(), ' @ ', cpu.speed, 'MHz'].join(''); if(!cpus[id]){ cpus[id]= 1; }else{ cpus[id]++; } }); console.log('CPU:' + Object.entries(cpus).map(function(data){ return [' ', data[1], ' x ', data[0]].join(''); }).join('\n')); console.log('----------------------------------------------------------------'); suite .add('EventEmitterHeatUp', function() { emitterB.on('test3', function () { 1==1; }); emitterB.emit('test3'); emitterB.removeAllListeners('test3'); }) .add('EventEmitter', function() { emitter.on('test1', function () { 1==1; }); emitter.emit('test1'); emitter.removeAllListeners('test1'); }) .add('EventEmitter2', function() { emitter2.on('test2', function () { 1==1; }); emitter2.emit('test2'); emitter2.removeAllListeners('test2'); }) .add('EventEmitter2 (wild)', function() { wildcardEmitter.on('test2.foo', function () { 1==1; }); wildcardEmitter.emit('test2.foo'); wildcardEmitter.removeAllListeners('test2.foo'); }) .add('EventEmitter2 (wild) using plain events', function() { wildcardEmitter.on('test2', function () { 1==1; }); wildcardEmitter.emit('test2'); wildcardEmitter.removeAllListeners('test2'); }) .add('EventEmitter2 (wild) emitting ns', function() { wildcardEmitter2.emit('test2.foo'); }) .add('EventEmitter2 (wild) emitting a plain event', function() { wildcardEmitter2.emit('test2'); }) .add('EventEmitter3', function() { emitter3.on('test2', function () { 1==1; }); emitter3.emit('test2'); emitter3.removeAllListeners('test2'); }) .on('cycle', function(event, bench) { console.log(String(event.target)); }) .on('complete', function() { console.log('\nFastest is ' + this.filter('fastest').map('name')); }) .run(true); EventEmitter2-6.4.7/test/perf/package.json000066400000000000000000000002021427200005100204070ustar00rootroot00000000000000{ "name": "benchmarks", "version": "0.0.0", "dependencies": { "benchmark": "2.1.x", "eventemitter3": "latest" } } EventEmitter2-6.4.7/test/perf/steadyEmmiting.js000066400000000000000000000122341427200005100214520ustar00rootroot00000000000000 var Benchmark = require('benchmark'); var suite = new Benchmark.Suite(); // basic emitter var EventEmitter = require('events').EventEmitter; var emitter = new EventEmitter(); var EventEmitter2 = require('../../lib/eventemitter2').EventEmitter2; // Emitter2 variations var emitter2 = new EventEmitter2(); var emitter3 = new EventEmitter2(); var emitter4 = new EventEmitter2({wildcard:true}); var emitter5 = new EventEmitter2({wildcard:true}); var emitter6 = new EventEmitter2(); var emitter7 = new EventEmitter2({wildcard:true}); var t; emitter.on('test1', function () { t=1; }); emitter.on('test1', function () { t=1; }); emitter.on('test2.foo', function () { t=1; }); emitter2.on('test1', function () { t=1; }); emitter2.on('test2', function () { t=1; }); emitter2.on('test2.foo', function () { t=1; }); emitter3.on('test1', function () { t=1; }); emitter3.on('test2', function () { t=1; }); emitter3.on('test2.foo', function () { t=1; }); emitter3.onAny( function () { t=1; }); emitter4.on('test1', function () { t=1; }); emitter4.on('test2', function () { t=1; }); emitter4.on('test2.foo', function () { t=1; }); emitter5.on('test1', function () { t=1; }); emitter5.on('test2', function () { t=1; }); emitter5.on('test2.foo', function () { t=1; }); emitter5.onAny( function () { t=1; }); emitter6.on('test1', function () { t=1; }); emitter6.on('test1', function () { t=1; }); emitter6.on('test1', function () { t=1; }); emitter6.on('test1', function () { t=1; }); emitter6.on('test2', function () { t=1; }); emitter6.on('test4', function () { t=1; }); emitter6.on('test5', function () { t=1; }); emitter6.on('test6', function () { t=1; }); emitter6.on('test7', function () { t=1; }); emitter6.onAny( function () { t=1; }); emitter6.onAny( function () { t=1; }); emitter6.onAny( function () { t=1; }); emitter6.onAny( function () { t=1; }); emitter7.on('test1.one', function () { t=1; }); emitter7.on('*.one', function () { t=1; }); emitter7.on('test1.one', function () { t=1; }); emitter7.on('test1.two', function () { t=1; }); emitter7.on('*.two', function () { t=1; }); emitter7.on('*.*', function () { t=1; }); emitter7.on('test1.*', function () { t=1; }); emitter7.on('**', function () { t=1; }); emitter7.on('*.*', function () { t=1; }); emitter7.onAny( function () { t=1; }); emitter7.onAny( function () { t=1; }); emitter7.onAny( function () { t=1; }); emitter7.onAny( function () { t=1; }); suite .add('Test HeatUp', function() { emitter.emit('test1'); }) .add('All at once', function () { for (var emmiter in [emitter2,emitter3,emitter4,emitter5,emitter6]) { emitter.emit('test1'); emitter.emit('test1',1); emitter.emit('test1',1,2); emitter.emit('test1',1,2,3); } emitter7.emit('test1.one'); emitter7.emit('test1.one',1); emitter7.emit('test1.one',1,2); emitter7.emit('test1.one',1,2,3); }) .add('EventEmitter', function() { emitter.emit('test1'); }) .add('EventEmitter 1', function() { emitter.emit('test1',1); }) .add('EventEmitter 1 2', function() { emitter.emit('test1',1,2); }) .add('EventEmitter 1 2 3', function() { emitter.emit('test1',1,2,3); }) .add('EventEmitter2', function() { emitter2.emit('test1'); }) .add('EventEmitter2 1', function() { emitter2.emit('test1',1); }) .add('EventEmitter2 1 2', function() { emitter2.emit('test1',1,2); }) .add('EventEmitter2 1 2 3', function() { emitter2.emit('test1',1,2,3); }) .add('EventEmitter2 +any', function() { emitter3.emit('test1',1); }) .add('EventEmitter2 +any 1', function() { emitter3.emit('test1',1); }) .add('EventEmitter2 +any 1 2', function() { emitter3.emit('test1',1,2); }) .add('EventEmitter2 +any 1 2 3', function() { emitter3.emit('test1',1,2,3); }) .add('EventEmitter2 wild', function() { emitter4.emit('test1'); }) .add('EventEmitter2 wild 1', function() { emitter4.emit('test1',1); }) .add('EventEmitter2 wild 1 2', function() { emitter4.emit('test1',1,2); }) .add('EventEmitter2 wild 1 2 3', function() { emitter4.emit('test1',1,2,3); }) .add('EventEmitter2 wild +any', function() { emitter5.emit('test1'); }) .add('EventEmitter2 wild +any 1', function() { emitter5.emit('test1',1); }) .add('EventEmitter2 wild +any 1 2', function() { emitter5.emit('test1',1,2); }) .add('EventEmitter2 wild +any 1 2 3', function() { emitter5.emit('test1',1,2,3); }) .add('EventEmitter2 complex', function() { emitter6.emit('test1'); }) .add('EventEmitter2 complex 1', function() { emitter6.emit('test1',1); }) .add('EventEmitter2 complex 1 2', function() { emitter6.emit('test1',1,2); }) .add('EventEmitter2 complex 1 2 3', function() { emitter6.emit('test1',1,2,3); }) .add('EventEmitter2 wild complex', function() { emitter7.emit('test1.one'); }) .add('EventEmitter2 wild complex 1', function() { emitter7.emit('test1.one',1); }) .add('EventEmitter2 wild complex 1 2', function() { emitter7.emit('test1.one',1,2); }) .add('EventEmitter2 wild complex 1 2 3', function() { emitter7.emit('test1.one',1,2,3); }) .on('cycle', function(event, bench) { console.log(String(event.target)); }) .run(true); EventEmitter2-6.4.7/test/simple/000077500000000000000000000000001427200005100164645ustar00rootroot00000000000000EventEmitter2-6.4.7/test/simple/addListener.js000066400000000000000000000217061427200005100212660ustar00rootroot00000000000000var assert= require('assert'); var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. Add a single listener on a single event.': function (test) { var emitter = new EventEmitter2({ verbose: true }); emitter.on('test1', function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners('test1').length, 1, 'There are three emitters'); test.expect(1); test.done(); }, '2. Add two listeners on a single event.': function (test) { var emitter = new EventEmitter2({ verbose: true }); emitter.on('test1', function () { test.ok(true, 'The event was raised'); }); emitter.on('test1', function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners('test1').length, 2, 'There are three emitters'); test.expect(1); test.done(); }, '3. Add three listeners on a single event.': function (test) { var emitter = new EventEmitter2({ verbose: true }); emitter.on('test1', function () { test.ok(true, 'The event was raised'); }); emitter.on('test1', function () { test.ok(true, 'The event was raised'); }); emitter.on('test1', function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners('test1').length, 3, 'There are three emitters'); test.expect(1); test.done(); }, '4. Add two listeners to two different events.': function (test) { var emitter = new EventEmitter2({ verbose: true }); emitter.on('test1', function () { test.ok(true, 'The event was raised'); }); emitter.on('test1', function () { test.ok(true, 'The event was raised'); }); emitter.on('test2', function () { test.ok(true, 'The event was raised'); }); emitter.on('test2', function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners('test1').length, 2, 'There are two emitters'); test.equal(emitter.listeners('test2').length, 2, 'There are two emitters'); test.expect(2); test.done(); }, '5. Never adding any listeners should yield a listeners array with the length of 0.': function (test) { var emitter = new EventEmitter2({ verbose: true }); emitter.on('test1', function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners('test2').length, 0, 'There are no emitters'); test.expect(1); test.done(); }, '6. the listener added should be the right listener.': function (test) { var emitter = new EventEmitter2({ verbose: true }); var type = 'somelistenerbar'; var f = function () {}; emitter.on(type, f); test.equal(emitter.listeners(type).length, 1, 'There are is one emitters'); test.equal(emitter.listeners(type)[0], f, 'The function should be f'); test.expect(2); test.done(); }, '7. should be able to listen on any event' : function (test) { var emitter = new EventEmitter2({ verbose: true }); var eventBeingTestedFor, expectedArgument; var f = function (event, argument) { test.ok(true, 'the event was fired'); test.ok(eventBeingTestedFor === event, 'the event is '+event); test.ok(expectedArgument === argument, 'the argument is '+argument) }; emitter.onAny(f); emitter.emit(eventBeingTestedFor = 'test23.ns5.ns5', expectedArgument = 'someData'); //1 emitter.offAny(f); expectedArgument = undefined; emitter.emit(eventBeingTestedFor = 'test21'); //0 emitter.onAny(f); emitter.onAny(f); emitter.emit(eventBeingTestedFor = 'test23.ns5.ns5', expectedArgument = 'someData'); //3 test.expect(3*3); test.done(); }, '8. should be able to listen on any event (should cause an error)' : function (test) { var emitter = new EventEmitter2({ verbose: true }); var f = function () { test.ok(true, 'the event was fired'); }; emitter.onAny(f); emitter.emit('error'); test.expect(1); test.done(); }, '9. onAny alias' : function (test) { var emitter = new EventEmitter2({ verbose: true }); var f = function () { test.ok(true, 'the event was fired'); }; emitter.on(f); emitter.emit('foo'); emitter.emit('bar'); test.expect(2); test.done(); }, '10. onAny with invalid argument' : function (test) { var emitter = new EventEmitter2({ verbose: true }); test.throws(function () { emitter.onAny(null); }, 'An exception should be thrown'); test.ok(!emitter.emit('foo'), 'emit should not return true'); test.expect(2); test.done(); }, '11. listenerCount should return the number of listeners': function (test) { var emitter = new EventEmitter2({ verbose: true }); test.equal(emitter.listenerCount('test1'), 0, 'Before adding listeners listenerCount is 0'); emitter.on('test1', function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listenerCount('test1'), 1, 'After adding a listener listenerCount is 1'); emitter.on('test1', function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners('test1').length, 2, 'And then there were 2'); test.expect(3); test.done(); }, '12. should support wrapping handler to an async listener': function (done) { var ee= new EventEmitter2(); var counter= 0; var f= function(x){ assert.equal(x, 123); counter++; }; ee.on('test', f, false); assert.equal(ee.listenerCount(), 1); ee.emit('test', 123); assert.equal(counter, 0, 'the event was emitted synchronously'); setTimeout(function(){ assert.equal(counter, 1); ee.off('test', f); assert.equal(ee.listenerCount(), 0); done(); }, 10); }, '13. should support wrapping handler to a promised listener using setImmediate': function (done) { var ee= new EventEmitter2(); var counter= 0; var f= function(x){ assert.equal(x, 123); counter++; return x + 1; }; ee.on('test', f, {promisify: true}); ee.emitAsync('test', 123).then(function(arg){ assert.equal(counter, 1); assert.equal(arg, 124); done(); }, done); assert.equal(counter, 0,'the event was emitted synchronously'); }, '13. should support wrapping handler to an async listener using nextTick': function (done) { var ee= new EventEmitter2(); var counter= 0; var f= function(x){ assert.equal(x, 123); counter++; }; ee.on('test', f, {nextTick: true}); assert.equal(ee.listenerCount(), 1); ee.emit('test', 123); assert.equal(counter, 0, 'the event was emitted synchronously'); process.nextTick(function(){ assert.equal(counter, 1); ee.off('test', f); assert.equal(ee.listenerCount(), 0); done(); }); }, '14. should support wrapping once listener to an async listener': function (done) { var ee = new EventEmitter2(); var counter = 0; var f = function (x) { assert.equal(x, 123); counter++; }; ee.once('test', f, false); assert.equal(ee.listenerCount(), 1); ee.emit('test', 123); assert.equal(counter, 0, 'the event was emitted synchronously'); setTimeout(function () { assert.equal(counter, 1); ee.off('test', f); assert.equal(ee.listenerCount(), 0); done(); }, 10); }, '15. should support returning a listener object if the objectify options is set': function () { var ee = new EventEmitter2(); var counter = 0; var handler = function (x) { assert.equal(x, 123); counter++; }; var listener= ee.on('test', handler, { objectify: true }); assert.equal(typeof listener, 'object'); assert.equal(listener.constructor.name, 'Listener'); assert.equal(typeof listener.off, 'function'); assert.equal(listener.emitter, ee); assert.equal(listener.event, 'test'); assert.equal(listener.listener, handler); assert.equal(counter, 0); ee.emit('test', 123); assert.equal(counter, 1); listener.off(); ee.emit('test', 123); assert.equal(counter, 1); }, '16. should support returning a listener object using the `once` method if the objectify options is set': function () { var ee = new EventEmitter2(); var counter = 0; var handler = function (x) { assert.equal(x, 123); counter++; }; var listener= ee.once('test', handler, { objectify: true }); assert.equal(typeof listener, 'object'); assert.equal(listener.constructor.name, 'Listener'); assert.equal(typeof listener.off, 'function'); assert.equal(listener.emitter, ee); assert.equal(listener.event, 'test'); assert.equal(listener.listener._origin, handler); assert.equal(counter, 0); listener.off(); ee.emit('test', 123); assert.equal(counter, 0); } }); EventEmitter2-6.4.7/test/simple/emit.js000066400000000000000000000120531427200005100177610ustar00rootroot00000000000000 var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. Add two listeners on a single event and emit the event.': function (test) { var emitter = new EventEmitter2({ verbose: true }); function functionA() { test.ok(true, 'The event was raised'); } function functionB() { test.ok(true, 'The event was raised'); } emitter.on('test2', functionA); emitter.on('test2', functionB); emitter.emit('test2'); test.expect(2); test.done(); }, '2. Add two listeners on a single event and emit the event twice.': function (test) { var emitter = new EventEmitter2({ verbose: true }); function functionA() { test.ok(true, 'The event was raised'); } function functionB() { test.ok(true, 'The event was raised'); } emitter.on('test2', functionA); emitter.on('test2', functionB); emitter.emit('test2'); emitter.emit('test2'); test.expect(4); test.done(); }, '3. Add two listeners on a single event and emit the event with a parameter.': function (test) { var emitter = new EventEmitter2({ verbose: true }); function functionA(value1) { test.ok(true, 'The event was raised'); test.equal(typeof value1, 'string', 'The event was raised'); } function functionB(value1) { test.ok(true, 'The event was raised'); test.equal(typeof value1, 'string', 'The event was raised'); } emitter.on('test2', functionA); emitter.on('test2', functionB); emitter.emit('test2', 'Hello, Node'); test.expect(4); test.done(); }, '4. Add two listeners on an single event and emit the event twice with a parameter.': function (test) { var emitter = new EventEmitter2({ verbose: true }); function functionA(value1) { test.ok(true, 'The event was raised'); test.equal(typeof value1, 'string', 'The event was raised'); } function functionB(value1) { test.ok(true, 'The event was raised'); test.equal(typeof value1, 'string', 'The event was raised'); } emitter.on('test2', functionA); emitter.on('test2', functionB); emitter.emit('test2', 'Hello, Node1'); emitter.emit('test2', 'Hello, Node2'); test.expect(8); test.done(); }, '5. Add two listeners on an single event and emit the event twice with multiple parameters.': function (test) { var emitter = new EventEmitter2({ verbose: true }); function functionA(value1, value2, value3) { test.ok(true, 'The event was raised'); test.equal(typeof value1, 'string', 'The value named "value1" is OK'); test.equal(typeof value2, 'string', 'The value named "value2" is OK'); test.equal(typeof value3, 'string', 'The value named "value3" is OK'); } function functionB(value1, value2, value3) { test.ok(true, 'The event was raised'); test.equal(typeof value1, 'string', 'The value named "value1" is OK'); test.equal(typeof value2, 'string', 'The value named "value2" is OK'); test.equal(typeof value3, 'string', 'The value named "value3" is OK'); } emitter.on('test2', functionA); emitter.on('test2', functionB); emitter.emit('test2', 'Hello, Node1', 'Hello, Node2', 'Hello, Node3'); emitter.emit('test2', 'Hello, Node1', 'Hello, Node2', 'Hello, Node3'); test.expect(16); test.done(); }, '6. Check return values of emit.': function (test) { var emitter = new EventEmitter2({ verbose: true }); function functionA() { test.ok(true, 'The event was raised'); } emitter.on('test6', functionA); test.ok(emitter.emit('test6'), 'emit should return true after calling a listener'); test.ok(!emitter.emit('other'), 'emit should return false when no listener was called'); emitter.onAny(functionA); test.ok(emitter.emit('other'), 'emit should return true after calling an onAny() listener'); test.expect(5); test.done(); }, '7. Check return values of wildcardEmitter.emit.': function (test) { var emitter = new EventEmitter2({ verbose: true, wildcard: true }); function functionA() { test.ok(true, 'The event was raised'); } emitter.on('test7', functionA); emitter.on('wildcard.*', functionA); test.ok(emitter.emit('test7'), 'emit should return true after calling a listener'); test.ok(emitter.emit('wildcard.7'), 'emit should return true after calling a wildcard listener'); test.ok(!emitter.emit('other7'), 'emit should return false when no listener was called'); test.ok(!emitter.emit('other.7'), 'emit should return false when no wildcard listener was called'); test.expect(6); test.done(); }, '8. Emit event with more than 2 arguments': function (test) { var emitter = new EventEmitter2({ verbose: true }); emitter.on('test', function(x,y,z){ test.equal(x, 1); test.equal(y, 2); test.equal(z, 3); }); emitter.emit('test', 1, 2, 3); test.expect(3); test.done(); } }); EventEmitter2-6.4.7/test/simple/emitAsync.js000066400000000000000000000053401427200005100207600ustar00rootroot00000000000000var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. Receive two results from single event.': function (test) { var emitter = new EventEmitter2({ verbose: true }); emitter.on('foo',function() { return 1; }); emitter.on('foo',function() { return 2; }); emitter.emitAsync('foo') .then(function(results){ test.equal(results[0], 1) test.equal(results[1], 2) test.done(); }); }, '2. Receive two results from single event via promises.': function (test) { var emitter = new EventEmitter2({ verbose: true }); emitter.on('foo',function(i) { return new Promise(function(resolve){ setTimeout(function(){ resolve(i+3); },50); }); }); emitter.on('foo',function(i) { return new Promise(function(resolve){ resolve(i+2) }); }); emitter.on('foo',function(i) { return Promise.resolve(i+1); }); emitter.on('foo',function(i) { return i+0; }); emitter.on('foo',function(i) { }); emitter.emitAsync('foo',0) .then(function(results){ test.equal(results[0], 3, 'should be 3') test.equal(results[1], 2, 'should be 2') test.equal(results[2], 1, 'should be 1') test.equal(results[3], 0, 'should be 0') test.equal(results[4], undefined, 'should be undefined') test.done(); }); }, '3. Receive two results from single event with once.': function (test) { var emitter = new EventEmitter2({ verbose: true }); emitter.once('foo',function() { return new Promise(function(resolve){ resolve(1); }); }); emitter.on('foo',function() { return new Promise(function(resolve){ resolve(2); }); }); emitter.emitAsync('foo') .then(function(results){ test.equal(results[0], 1) test.equal(results[1], 2) test.done(); }); }, '4. Return value is always promise': function (test) { var emitter = new EventEmitter2({ verbose: true }); emitter.on('foo', function() { return new Promise(function(resolve){ resolve(1); }) }); test.ok(emitter.emitAsync('foo') instanceof Promise); test.ok(emitter.emitAsync('bar') instanceof Promise); emitter.onAny(function() { return new Promise(function(resolve){ resolve(2); }) }); test.ok(emitter.emitAsync('error') instanceof Promise); emitter.emitAsync('error') .then(function(results){ test.equal(results[0], 2) test.done(); }); }, });EventEmitter2-6.4.7/test/simple/eventNames.js000066400000000000000000000012211427200005100211230ustar00rootroot00000000000000var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. Test event names function.': function (test) { var emitter = new EventEmitter2({ verbose: true }); emitter.on('foo', () => {}); emitter.on('bar', () => {}); var eventNames = emitter.eventNames(); eventNames.sort(); test.equal(eventNames.length, 2); test.equal(eventNames[0],'bar'); test.equal(eventNames[1],'foo'); test.done(); } }); EventEmitter2-6.4.7/test/simple/listenTo.js000066400000000000000000000133271427200005100206310ustar00rootroot00000000000000var assert = require('assert'); var EventEmitter = require('events').EventEmitter; var file = '../../lib/eventemitter2'; var EventEmitter2; if (typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = { '1. should listen events': function () { var isEmitted= false; var ee = new EventEmitter(); var ee2 = new EventEmitter2(); ee2.listenTo(ee, 'test'); ee2.on('test', function () { isEmitted = true; }); ee.emit('test'); assert.equal(isEmitted, true); }, '2. should attach listeners to the target object on demand if newListener & removeListener options activated': function () { var isEmitted= false; var ee = new EventEmitter(); var ee2 = new EventEmitter2({ newListener: true, removeListener: true }); ee2.listenTo(ee, { 'foo': 'bar' }); assert.equal(ee.listenerCount('foo'), 0); ee2.on('bar', function () { isEmitted = true; }); assert.equal(ee.listenerCount('foo'), 1); ee.emit('foo'); assert.equal(isEmitted, true); }, '3. should handle listener data': function () { var isEmitted= false; var ee = new EventEmitter(); var ee2 = new EventEmitter2(); ee2.listenTo(ee, 'test'); ee2.on('test', function (a, b, c) { isEmitted = true; assert.equal(a, 1); assert.equal(b, 2); assert.equal(c, 3); }); assert.equal(ee.listenerCount('test'), 1); ee.emit('test', 1, 2, 3); assert.equal(isEmitted, true); }, '4. should support stopListeningTo method': function () { var counter= 0; var ee = new EventEmitter(); var ee2 = new EventEmitter2(); ee2.listenTo(ee, 'test'); ee2.on('test', function () { counter++; }); assert.equal(ee.listenerCount('test'), 1); ee.emit('test'); ee.emit('test'); ee2.stopListeningTo(ee); ee.emit('test'); assert.equal(counter, 2); assert.equal(ee.listenerCount('test'), 0); }, '5. should support listening of multiple events': function () { var emitted1= false; var emitted2= false; var ee = new EventEmitter(); var ee2 = new EventEmitter2(); ee2.listenTo(ee, 'test1 test2'); ee2.on('test1', function () { emitted1= true; }); ee2.on('test2', function () { emitted2= true; }); assert.equal(ee.listenerCount('test1'), 1); assert.equal(ee.listenerCount('test2'), 1); ee.emit('test1'); ee.emit('test2'); assert.equal(emitted1, true); assert.equal(emitted2, true); }, '6. should support events mapping': function () { var emitted1= false; var emitted2= false; var ee = new EventEmitter(); var ee2 = new EventEmitter2(); ee2.listenTo(ee, { test1: 'foo', test2: 'bar' }); ee2.on('foo', function (x) { emitted1= true; assert.equal(x, 1); }); ee2.on('bar', function (y) { emitted2= true; assert.equal(y, 2); }); assert.equal(ee.listenerCount('test1'), 1); assert.equal(ee.listenerCount('test2'), 1); ee.emit('test1', 1); ee.emit('test2', 2); assert.equal(emitted1, true); assert.equal(emitted2, true); }, '7. should support event reducer': function () { var counter1= 0; var counter2= 0; var ee = new EventEmitter(); var ee2 = new EventEmitter2(); ee2.listenTo(ee, { test1: 'foo', test2: 'bar' }, { reducers: { test1: function(event){ assert.equal(event.name, 'foo'); return event.data[0]!=='ignoreTest'; }, test2: function(event){ assert.equal(event.name, 'bar'); event.data[0]= String(event.data[0]); } } }); ee2.on('foo', function (x) { counter1++; assert.equal(x, 456); }); ee2.on('bar', function (y) { counter2++; assert.equal(y, '123'); }); ee.emit('test1', 'ignoreTest'); ee.emit('test1', 456); ee.emit('test2', 123); ee.emit('test2', 123); assert.equal(counter1, 1); assert.equal(counter2, 2); }, '8. should support a single reducer for multiple events': function () { var counter1= 0; var ee = new EventEmitter(); var ee2 = new EventEmitter2(); ee2.listenTo(ee, { test1: 'foo', test2: 'bar' }, { reducers: function(){ counter1++; } }); ee.emit('test1'); ee.emit('test2'); assert.equal(counter1, 2); }, '9. should detach the listener from the target when the last listener was removed from the emitter': function () { var ee = new EventEmitter(); var ee2 = new EventEmitter2({ newListener: true, removeListener: true }); ee2.listenTo(ee, { 'foo': 'bar' }); assert.equal(ee.listenerCount('foo'), 0); var handler= function(){}; ee2.on('bar', handler); assert.equal(ee.listenerCount('foo'), 1); ee2.off('bar', handler); assert.equal(ee.listenerCount('foo'), 0); } }; EventEmitter2-6.4.7/test/simple/once.js000066400000000000000000000111011427200005100177400ustar00rootroot00000000000000var BBPromise = require("bluebird"); var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; BBPromise.config({ cancellation: true }); if (typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. should return a Promise': function (test) { var ee = new EventEmitter2(); var result = EventEmitter2.once(ee, 'event'); test.ok(result instanceof Promise); test.done(); }, '2. should resolve the promise when a specific event occurs': function (test) { var ee = new EventEmitter2(); var timer = setTimeout(function () { throw Error('timeout'); }, 100); EventEmitter2.once(ee, 'event').then(function () { clearTimeout(timer); test.done(); }, function (err) { clearTimeout(timer); throw err; }); ee.emit('event'); }, '3. should handle the event data arguments as an array': function (test) { var ee = new EventEmitter2(); EventEmitter2.once(ee, 'event').then(function (data) { test.deepEqual(data, [1, 2, 3]); test.done(); }, function (err) { throw err; }); ee.emit('event', 1, 2, 3); }, '4. should reject the promise if an error event emitted': function (test) { var ee = new EventEmitter2(); var message = 'test'; var timer = setTimeout(function () { throw Error('timeout'); }, 100); EventEmitter2.once(ee, 'event').then(function () { clearTimeout(timer); throw Error('unexpected promise resolving'); }, function (err) { clearTimeout(timer); test.equal(err.message, message); test.done(); }); ee.emit('error', new Error(message)); }, '5. should support cancellation': function (test) { var ee = new EventEmitter2(); var message = 'canceled'; var timer = setTimeout(function () { throw Error('test timeout'); }, 100); var promise = EventEmitter2.once(ee, 'event'); promise.then(function () { clearTimeout(timer); throw Error('unexpected promise resolving'); }, function (err) { clearTimeout(timer); test.equal(err.message, message); test.done(); }); setTimeout(function () { promise.cancel(); }, 50); }, '6. should support timeout handling': function (test) { var ee = new EventEmitter2(); var message = 'timeout'; var timer = setTimeout(function () { throw Error('test timeout'); }, 100); var promise = EventEmitter2.once(ee, 'event', { timeout: 10 }); promise.then(function () { clearTimeout(timer); throw Error('unexpected promise resolving'); }, function (err) { clearTimeout(timer); test.equal(err.message, message); test.done(); }); }, '7. should support BlueBird promises': function (test) { var ee = new EventEmitter2(); EventEmitter2.once(ee, 'event', { Promise: BBPromise }).then(function (data) { test.deepEqual(data, [1, 2, 3]); test.done(); }, function (err) { throw err; }); ee.emit('event', 1, 2, 3); }, '8. should support BlueBird promise silent cancellation': function (test) { var ee = new EventEmitter2(); var bbPromise= EventEmitter2.once(ee, 'event', { Promise: BBPromise }).then(function () { throw Error('unexpected promise resolving'); }, function () { throw Error('unexpected promise rejecting'); }); bbPromise.cancel(); ee.emit('event'); setTimeout(function(){ test.done(); }, 50); }, '9. should support overloading cancellation api': function (test) { var ee = new EventEmitter2(); var message= 'canceled'; var bbPromise= EventEmitter2.once(ee, 'event', { Promise: BBPromise, overload: true }); bbPromise.then(function () { throw Error('unexpected promise resolving'); }, function (err) { test.equal(err.message, message); test.done(); }); bbPromise.cancel(); } }); EventEmitter2-6.4.7/test/simple/prepend.js000066400000000000000000000026511427200005100204630ustar00rootroot00000000000000var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. Add a listener before another one on a single event.': function (test) { var emitter = new EventEmitter2({ verbose: true }); var raised = false; var second = function () { test.ok(raised, 'The event was raised in incorrect order'); test.done(); }; emitter.on('test1', second); var first = function () { test.ok(!raised, 'The event was raised in incorrect order'); raised = true; }; emitter.prependListener('test1', first); test.equal(emitter.listeners('test1').length, 2); test.equal(emitter.listeners('test1')[0], first); test.equal(emitter.listeners('test1')[1], second); emitter.emit('test1'); }, '2. prepend listener for any event' : function (test) { var emitter = new EventEmitter2({ verbose: true }); var raised = false; var second = function () { test.ok(raised, 'The event was raised in incorrect order'); test.done(); }; emitter.onAny(second); var first = function () { test.ok(!raised, 'The event was raised in incorrect order'); raised = true; }; emitter.prependAny(first); emitter.emit('random'); } }); EventEmitter2-6.4.7/test/simple/reconfigure.js000066400000000000000000000044501427200005100213350ustar00rootroot00000000000000var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ 'reconfigure1. initialize, removeAllListeners' : function (test) { var emitter, config = { wildcard: true, // should the event emitter use wildcards. delimiter: '::::', // the delimiter used to segment namespaces, defaults to `.`. maxListeners: 20 // the max number of listeners that can be assigned to an event, defaults to 10. }; emitter = new EventEmitter2(config); emitter.removeAllListeners(); test.equal(emitter._maxListeners, config.maxListeners, 'should be ' + config.maxListeners); test.equal(emitter._conf.maxListeners, config.maxListeners, 'should be ' + config.maxListeners); test.equal(emitter._conf.delimiter, config.delimiter, 'should be ' + config.delimiter); test.equal(emitter._conf.wildcard, config.wildcard, 'should be ' + config.wildcard); test.expect(4); test.done(); }, 'reconfigure1. setMaxListeners, removeAllListeners' : function (test) { var emitter, amount = 99; emitter = new EventEmitter2(); emitter.setMaxListeners(amount); emitter.removeAllListeners(); test.equal(emitter._maxListeners, amount, 'should be ' + amount); test.equal(emitter._conf.maxListeners, amount, 'should be ' + amount); test.expect(2); test.done(); }, 'getMaxListeners': function (test) { var emitter = new EventEmitter2(), amount = 10; //default amount test.equal(emitter.getMaxListeners(), amount, 'should be ' + amount); amount= 99; emitter.setMaxListeners(amount); test.equal(emitter.getMaxListeners(), amount, 'should be ' + amount); test.done(); }, 'defaultMaxListeners': function (test) { var defaultAmount = 10, amount = defaultAmount; test.equal(EventEmitter2.defaultMaxListeners, amount, 'should be ' + amount); amount = 99; EventEmitter2.defaultMaxListeners = amount; test.equal(EventEmitter2.defaultMaxListeners, amount, 'should be ' + amount); EventEmitter2.defaultMaxListeners = defaultAmount; // rollback test.done(); } }); EventEmitter2-6.4.7/test/simple/removeListener.js000066400000000000000000000127401427200005100220310ustar00rootroot00000000000000 var simpleEvents= require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } const setupRemoveListenerTest = (times) => { const emitter = new EventEmitter2; const type = 'remove'; const f = registerRemoveListeners(emitter, type, times); return {emitter, type, f}; } const registerRemoveListeners = (emitter, type, times) => { const f = function f() { test.ok(true, 'event was raised'); }; for (let i = 0; i < times; i++) { emitter.on(type, f) } return f; }; module.exports = simpleEvents({ 'removeListener1. adding 1, removing 1' : function (test) { const {emitter, type, f} = setupRemoveListenerTest(1); let listeners; listeners = emitter.listeners(type); test.equal(listeners.length, 1, 'should only have 1'); //remove emitter.removeListener(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 0, 'should be 0'); test.expect(2); test.done(); }, 'removeListener2. adding 2, removing 1' : function (test) { const {emitter, type, f} = setupRemoveListenerTest(2); let listeners; listeners = emitter.listeners(type); test.equal(listeners.length, 2, 'should only have 2'); //remove emitter.removeListener(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 1, 'should be 1'); test.expect(2); test.done(); }, 'removeListener3. adding 3, removing 1' : function (test) { const {emitter, type, f} = setupRemoveListenerTest(3); let listeners; listeners = emitter.listeners(type); test.equal(listeners.length, 3, 'should only have 3'); //remove emitter.removeListener(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 2, 'should be 2'); test.expect(2); test.done(); }, 'removeListener4. should error if we don\'t pass in a function' : function (test) { const {emitter, type, f} = setupRemoveListenerTest(1); let listeners; listeners = emitter.listeners(type); test.equal(listeners.length, 1, 'should only have 1'); //remove test.throws(function () {emitter.removeListener(type, type)}, Error, 'should throw an Error'); listeners = emitter.listeners(type); test.equal(listeners.length, 1, 'should be 1'); test.expect(3); test.done(); }, 'removeListener5. removing a different function, should not remove' : function (test) { var emitter = new EventEmitter2; var type = 'remove', listeners; var f = function f() { test.ok(true, 'event was raised'); }; var g = function g() { test.ok(true, 'event was raised'); }; emitter.on(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 1, 'should only have 1'); //remove emitter.removeListener(type, g); listeners = emitter.listeners(type); test.equal(listeners.length, 1, 'should be 1'); test.expect(2); test.done(); }, 'removeListener6. removing all functions by name' : function (test) { const {emitter, type, f} = setupRemoveListenerTest(10); let listeners; listeners = emitter.listeners(type); test.equal(listeners.length, 10, 'should only have 10'); emitter.removeListener(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 9, 'should be 9'); emitter.removeAllListeners(type); listeners = emitter.listeners(type); test.equal(listeners.length, 0, 'should be 0'); test.expect(3); test.done(); }, 'removeListener7. removing different event, should not remove' : function (test) { const {emitter, type, f} = setupRemoveListenerTest(10); let listeners; listeners = emitter.listeners(type); test.equal(listeners.length, 10, 'should only have 10'); emitter.removeListener(type+type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 10, 'should be 10'); emitter.removeAllListeners(type+type); listeners = emitter.listeners(type); test.equal(listeners.length, 10, 'should be 10'); emitter.removeAllListeners(type); listeners = emitter.listeners(type); test.equal(listeners.length, 0, 'should be 0'); test.expect(4); test.done(); }, 'removeListener8. when _events doesn\'t exist' : function (test) { var emitter = new EventEmitter2; var type = 'remove'; delete emitter._events; emitter.removeAllListeners(); emitter.removeAllListeners(type); test.expect(0); test.done(); }, 'removeListener9. removing all functions - no argument provided' : function(test) { const {emitter, type, f} = setupRemoveListenerTest(10); let listeners; listeners = emitter.listeners(type); test.equal(listeners.length, 10, 'should only have 10'); emitter.removeAllListeners(); listeners = emitter.listeners(type); test.equal(listeners.length, 0, 'should be 0'); test.expect(2); test.done(); }, 'removeListener10. removing all functions - argument provided is "undefined"' : function(test) { const {emitter, type, f} = setupRemoveListenerTest(10); let listeners; listeners = emitter.listeners(type); test.equal(listeners.length, 10, 'should only have 10'); emitter.removeAllListeners(undefined); listeners = emitter.listeners(type); test.equal(listeners.length, 0, 'should be 0'); test.expect(2); test.done(); } }); EventEmitter2-6.4.7/test/simple/setMax.js000066400000000000000000000112571427200005100202710ustar00rootroot00000000000000 var simpleEvents= require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ 'setMaxListener1. default behavior of 10 listeners.' : function (test) { var emitter = new EventEmitter2; for (var i = 0; i < 10; i++) { emitter.on('foobar', function () { test.ok(true, 'event was raised'); }); } var listeners = emitter.listeners('foobar'); test.equal(listeners.length, 10, 'should only have 10'); test.expect(1); test.done(); }, 'setMaxListener2. If we added more than 10, should not see them' : function (test) { var emitter = new EventEmitter2; for (var i = 0; i < 10 ; i++) { emitter.on('foobar2', function () { test.ok(true, 'event was raised'); }); } console.log('should see EE2 complaining:'); emitter.on('foobar2', function () { test.ok(true, 'event was raised'); }); var listeners = emitter.listeners('foobar2'); test.equal(listeners.length, 11, 'should have 11'); test.ok(emitter._events['foobar2'].warned, 'should have been warned'); test.expect(2); test.done(); }, 'setMaxListener3. if we set maxListener to be greater before adding' : function (test) { var emitter = new EventEmitter2; var type = 'foobar3'; // set to 20 emitter.setMaxListeners(20); for (var i = 0; i < 15 ; i++) { emitter.on(type, function () { test.ok(true, 'event was raised'); }); } var listeners = emitter.listeners(type); test.equal(listeners.length, 15, 'should have 15'); test.ok(!(emitter._events[type].warned), 'should not have been set'); test.expect(2); test.done(); }, 'setMaxListener4. should be able to change it right at 10' : function (test) { var emitter = new EventEmitter2; var type = 'foobar4'; for (var i = 0; i < 10 ; i++) { emitter.on(type, function () { test.ok(true, 'event was raised'); }); } emitter.setMaxListeners(9001); emitter.on(type, function () { test.ok(true, 'event was raised'); }); var listeners = emitter.listeners(type); test.equal(listeners.length, 11, 'should have 11'); test.ok(!(emitter._events[type].warned), 'should not have been set'); test.expect(2); test.done(); }, 'setMaxListener5. if we set maxListener to be 0 should add endlessly' : function (test) { var emitter = new EventEmitter2; var type = 'foobar'; // set to 0 emitter.setMaxListeners(0); for (var i = 0; i < 25 ; i++) { emitter.on(type, function () { test.ok(true, 'event was raised'); }); } var listeners = emitter.listeners(type); test.equal(listeners.length, 25, 'should have 25'); test.ok(!(emitter._events[type].warned), 'should not have been set'); test.expect(2); test.done(); }, 'setMaxListener6. if we set maxListener to be 1 should warn for 2 listeners' : function (test) { var emitter = new EventEmitter2; var type = 'ns1'; emitter.setMaxListeners(1); emitter.on(type, function () {}); emitter.on(type, function () {}); test.ok(emitter._events[type].warned, 'should have been set'); test.done(); }, 'maxListeners parameter 1. Passing maxListeners as a parameter should override default.' : function (test) { var emitter = new EventEmitter2({ maxListeners: 2 }); emitter.on('a', function () {}); emitter.on('a', function () {}); emitter.on('a', function () {}); test.ok(emitter._events.a.warned, '.on() should warn when maxListeners is exceeded.'); test.done(); }, 'maxListeners parameter 2. Passing maxListeners with value 0 as a parameter should override default.' : function (test) { var emitter = new EventEmitter2({ maxListeners: 0 }); var type = 'ns1'; for (var i = 0; i < 12 ; i++) { emitter.on(type, function () {}); } test.ok(!emitter._events[type].warned, 'should not have been set'); test.done(); }, 'should use process.emitWarning if available' : function (test) { // Don't run this test if `process.emitWarning` is not available if(typeof process === 'undefined' || !process.emitWarning) { test.done(); return; } test.expect(2); var emitter = new EventEmitter2; process.once('warning', function(warning) { test.equal(warning.name, 'MaxListenersExceededWarning'); test.equal(warning.count, 11); test.done(); }); for (var i = 0; i < 11 ; i++) { emitter.on('foobar2', function () { }); } } }); EventEmitter2-6.4.7/test/simple/symbol.js000066400000000000000000000022151427200005100203270ustar00rootroot00000000000000var assert= require('assert'); var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports= { 'should support symbol keys for plain events': function(){ var counter= 0; var ee= new EventEmitter2(); var event= Symbol('event'); var handler= function(){ counter++; }; ee.on(event, handler); assert.equal(ee.listenerCount(), 1); ee.emit(event); assert.equal(counter, 1); ee.off(event, handler); ee.emit(event); assert.equal(counter, 1); assert.equal(ee.listenerCount(), 0); }, 'should support symbol namespace for wildcard events': function(){ var counter= 0; var symbol= Symbol('test'); var ee= new EventEmitter2({ wildcard: true }); ee.on(['event', symbol], function(value){ counter++; assert.equal(value, 123); }); ee.emit(['event', symbol], 123); assert.equal(counter, 1); } }; EventEmitter2-6.4.7/test/simple/ttl.js000066400000000000000000000066701427200005100176360ustar00rootroot00000000000000 var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. A listener added with `once` should only listen once and then be removed.': function (test) { var emitter = new EventEmitter2(); emitter.once('test1', function () { test.ok(true, 'The event was raised once'); }); emitter.emit('test1'); emitter.emit('test1'); test.expect(1); test.done(); }, '2. A listener with a TTL of 4 should only listen 4 times.': function (test) { var emitter = new EventEmitter2(); emitter.many('test1', 4, function (value1) { test.ok(true, 'The event was raised 4 times.'); }); emitter.emit('test1', 1); emitter.emit('test1', 2); emitter.emit('test1', 3); emitter.emit('test1', 4); emitter.emit('test1', 5); test.expect(4); test.done(); }, '3. A listener with a TTL of 4 should only listen 4 times and pass parameters.': function (test) { var emitter = new EventEmitter2(); emitter.many('test1', 4, function (value1, value2, value3) { test.ok(typeof value1 !== 'undefined', 'got value 1'); test.ok(typeof value2 !== 'undefined', 'got value 2'); test.ok(typeof value3 !== 'undefined', 'got value 3'); }); emitter.emit('test1', 1, 'A', false); emitter.emit('test1', 2, 'A', false); emitter.emit('test1', 3, 'A', false); emitter.emit('test1', 4, 'A', false); emitter.emit('test1', 5, 'A', false); test.done(); }, '4. Remove an event listener by signature.': function (test) { var emitter = new EventEmitter2(); var count = 0; function f1(event) { "event A"; test.ok(true, 'The event was raised less than 3 times.'); } emitter.on('test1', f1); function f2(event) { "event B"; test.ok(true, 'The event was raised less than 3 times.'); } emitter.on('test1', f2); function f3(event) { "event C"; test.ok(true, 'The event was raised less than 3 times.'); } emitter.on('test1', f3); emitter.removeListener('test1', f2); emitter.emit('test1'); test.expect(2); test.done(); }, '5. `removeListener` and `once`': function(test) { var emitter = new EventEmitter2(); var functionA = function() { test.ok(true, 'Event was fired'); }; emitter.once('testA', functionA); emitter.removeListener('testA', functionA); emitter.emit('testA'); test.expect(0); test.done(); }, '6. `once` followed by `on` should work fine': function(test) { // the trick here is that listeners changed in between of // emit call var emitter = new EventEmitter2(); var functionA = function() { test.ok(true, 'Event was fired'); }; emitter.once('testA', functionA); emitter.on('testA', functionA); emitter.emit('testA'); test.expect(2); test.done(); }, '7. `onAny` handler that modifies `onAny` listerners should work fine': function(test) { // the trick here is that listeners changed in between of // emit call var emitter = new EventEmitter2(); var functionA = function() { test.ok(true, 'Event was fired'); }; emitter.onAny(function () { emitter.offAny(functionA); } ); emitter.onAny(functionA); emitter.emit('testA'); test.expect(1); test.done(); } }); EventEmitter2-6.4.7/test/waitFor/000077500000000000000000000000001427200005100166065ustar00rootroot00000000000000EventEmitter2-6.4.7/test/waitFor/waitFor.js000066400000000000000000000110111427200005100205510ustar00rootroot00000000000000var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; var assert= require('assert'); if (typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. should return thenable object that resolves when an event occurs': function (test) { var emitter = new EventEmitter2({verbose: true}); var thenable = emitter.waitFor('foo'); test.ok(typeof thenable.then === 'function', 'then method missing'); test.ok(typeof thenable.cancel === 'function', 'cancel method missing'); var timestamp; thenable.then(function (data) { if (Date.now() - timestamp < 0) { throw Error('premature resolving'); } test.equal(data.length, 2); test.equal(data[0], 1); test.equal(data[1], 2); test.done(); }, function (err) { throw err; }); setTimeout(function () { timestamp = Date.now(); emitter.emit('foo', 1, 2); }, 50); }, '2. should reject thenable if timeout': function (test) { var emitter = new EventEmitter2({verbose: true}); var timestamp = Date.now(); emitter.waitFor('foo', { timeout: 50 }).then(function () { throw Error('Unexpected promise resolving'); }, function (err) { if (Date.now() - timestamp < 0) { throw Error('premature rejecting'); } test.ok(err instanceof Error); test.equal(err.message, 'timeout'); test.done(); }); }, '3. should reject thenable if cancel method was called': function (test) { var emitter = new EventEmitter2({verbose: true}); var timestamp; var thenable = emitter.waitFor('foo'); thenable.then(function () { throw Error('Unexpected promise resolving'); }, function (err) { if (Date.now() - timestamp < 0) { throw Error('premature rejecting'); } test.ok(err instanceof Error); test.equal(err.message, 'canceled'); test.done(); }); setTimeout(function () { timestamp = Date.now(); thenable.cancel(); }, 50); }, '4. should handle an error when handleError option is used': function (test) { var emitter = new EventEmitter2({verbose: true}); emitter.waitFor('foo', { handleError: true }).then(function (data) { test.equal(data.length, 2); test.equal(data[0], 1); test.equal(data[1], 2); test.done(); }, function (err) { throw err; }); emitter.emit('foo', null, 1, 2) }, '5. should able to filter event by data using the filter callback option': function (test) { var emitter = new EventEmitter2({verbose: true}); emitter.waitFor('foo', { filter: function (arg0) { return arg0 === 2; }, timeout: 50 }).then(function (data) { test.equal(data[0], 2); test.done(); }, function (err) { throw err; }); emitter.emit('foo', 1); emitter.emit('foo', 2); }, '6. should clean internal listeners once its promise resolved': function (done) { var emitter = new EventEmitter2({verbose: true}); emitter.waitFor('foo', { filter: function (arg0) { return arg0 === 2; }, timeout: 50 }).then(function (data) { assert.equal(data[0], 2); assert.equal(emitter.listenerCount(), 0); done(); }).catch(done); assert.equal(emitter.listenerCount(), 1); emitter.emit('foo', 2); }, '7. should clean internal listeners once its promise resolved (wildcard)': function (done) { var emitter = new EventEmitter2({verbose: true, wildcard: true}); emitter.waitFor('foo.*', { filter: function (arg0) { return arg0 === 2; }, timeout: 50 }).then(function (data) { assert.equal(data[0], 2); assert.equal(emitter.listenerCount('**'), 0); done(); }).catch(done); assert.equal(emitter.listenerCount('**'), 1); emitter.emit('foo.bar', 2); } }); EventEmitter2-6.4.7/test/wildcardEvents/000077500000000000000000000000001427200005100201515ustar00rootroot00000000000000EventEmitter2-6.4.7/test/wildcardEvents/addListener.js000066400000000000000000000174541427200005100227600ustar00rootroot00000000000000 var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. Add a single listener on a single event.': function (test) { var emitter = new EventEmitter2({ wildcard: true }); var type = 'some.listener.bar'; emitter.on(type, function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners(type).length, 1, 'There are three emitters'); test.expect(1); test.done(); }, '1a. Add a single listener on a single event (using an array).': function (test) { var emitter = new EventEmitter2({ wildcard: true }); var type = ['some', 'listener', 'bar']; emitter.on(type, function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners(type).length, 1, 'There are three emitters'); test.expect(1); test.done(); }, '2. Add two listeners on a single event.': function (test) { var emitter = new EventEmitter2({ wildcard: true }); var type = 'some.listener.bar'; emitter.on(type, function () { test.ok(true, 'The event was raised'); }); emitter.on(type, function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners(type).length, 2, 'There are three emitters'); test.expect(1); test.done(); }, '2a. Add two listeners on a single event (using an array).': function (test) { var emitter = new EventEmitter2({ wildcard: true }); var type = ['some', 'listener', 'bar']; emitter.on(type, function () { test.ok(true, 'The event was raised'); }); emitter.on(type, function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners(type).length, 2, 'There are three emitters'); test.expect(1); test.done(); }, '3. Add three listeners on a single event.': function (test) { var emitter = new EventEmitter2({ wildcard: true }); var type = 'some.listener.bar'; emitter.on(type, function () { test.ok(true, 'The event was raised'); }); emitter.on(type, function () { test.ok(true, 'The event was raised'); }); emitter.on(type, function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners(type).length, 3, 'There are three emitters'); test.expect(1); test.done(); }, '4. Add two listeners to two different events.': function (test) { var emitter = new EventEmitter2({ wildcard: true }); var type = 'some.listener.bar'; emitter.on(type, function () { test.ok(true, 'The event was raised'); }); emitter.on(type, function () { test.ok(true, 'The event was raised'); }); emitter.on('test2', function () { test.ok(true, 'The event was raised'); }); emitter.on('test2', function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners(type).length, 2, 'There are two emitters'); test.equal(emitter.listeners('test2').length, 2, 'There are two emitters'); test.expect(2); test.done(); }, '5. Never adding any listeners should yield a listeners array with the length of 0.': function (test) { var emitter = new EventEmitter2({ wildcard: true }); var type = 'some.listener.bar'; emitter.on(type, function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners('test2').length, 0, 'There are no emitters'); test.expect(1); test.done(); }, '6. the listener added should be the right listener.': function (test) { var emitter = new EventEmitter2({ wildcard: true }); var type = 'some.listener.bar'; var f = function () {}; emitter.on(type, f); test.equal(emitter.listeners(type).length, 1, 'There are is one emitters'); test.equal(emitter.listeners(type)[0], f, 'The function should be f'); test.expect(2); test.done(); }, '7. Listeners on `*`, `*.*`, `*.test` with emissions from `foo.test` and `other.emit`': function (test) { var emitter = new EventEmitter2({ wildcard: true }); var f = function () { test.ok(true, 'the event was fired') }; emitter.on('*.test', f); emitter.on('*.*', f); emitter.on('*', f); emitter.emit('other.emit'); emitter.emit('foo.test'); test.expect(3); test.done(); }, '8. Listeners on `*`, `*.*`, foo.test with emissions from `*`, `*.*` and `foo.test`': function (test) { var emitter = new EventEmitter2({ wildcard: true }); var f = function () { test.ok(true, 'the event was fired') }; emitter.on('foo.test', f); emitter.on('*.*', f); emitter.on('*', f); emitter.emit('*.*'); emitter.emit('foo.test'); emitter.emit('*') test.expect(5); test.done(); }, '9. Listeners on `*`. (using an array)': function (test) { var emitter = new EventEmitter2({ wildcard: true }); var f = function () { test.ok(true, 'the event was fired') }; emitter.on(['*'], f); emitter.emit('*') test.expect(1); test.done(); }, '10. actual event name': function(test) { var emitter = new EventEmitter2({ wildcard: true }); emitter.on('foo', function() { emitter.emit('bar'); // changes the current event, passes the old one in as a parameter. }); emitter.on('*', function() { console.log(this.event); }); emitter.emit('foo'); test.done(); }, '11. Listeners with multi-level wildcards': function (test) { var emitter = new EventEmitter2({ wildcard: true }); var i = 0; var f = function (n) { return function() { //console.log('Event', n, 'fired by', this.event); test.ok(true, 'the event was fired'); }; }; emitter.on('**.test', f(i++)); // 0: 0 + 1 + 0 + 0 + 1 + 1 + 1 + 1 + 1 + 1 emitter.on('**.bar.**', f(i++)); // 1: 0 + 1 + 1 + 1 + 1 + 0 + 0 + 1 + 1 + 1 emitter.on('**.*', f(i++)); // 2: 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 emitter.on('*.**', f(i++)); // 3: 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 emitter.on('**', f(i++)); // 4: 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 emitter.on('other.**', f(i++)); // 5: 1 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 1 + 1 emitter.on('foo.**.test', f(i++)); // 6: 0 + 1 + 0 + 0 + 1 + 0 + 1 + 1 + 1 + 1 emitter.on('test.**', f(i++)); // 7: 0 + 0 + 0 + 0 + 1 + 1 + 0 + 0 + 1 + 1 // Add forbidden patterns for safety purpose. emitter.on('**.**', f(i++)); emitter.on('a.b.**.**', f(i++)); emitter.on('**.**.a.b', f(i++)); emitter.on('a.b.**.**.a.b', f(i++)); emitter.emit('other.emit'); // 4 emitter.emit('foo.bar.test'); // 6 emitter.emit('foo.bar.test.bar.foo.test.foo'); // 4 emitter.emit('bar.bar.bar.bar.bar.bar'); // 4 emitter.emit('**.*'); // 8 emitter.emit('test'); // 5 emitter.emit('foo.test'); // 5 emitter.emit('foo.**.*'); // 6 emitter.emit('**.test'); // 8 emitter.emit('**.test.**'); // 8 //emitter.emit('*.**.test.**.a'); // 0 test.expect(58); test.done(); }, '12. Check return values of emit for wildcard emitter.': function (test) { var emitter = new EventEmitter2({ wildcard: true }); emitter.on('foo.*', function () { test.ok(true, 'The event was raised'); }); emitter.onAny(function () { test.ok(true, 'The event was raised'); }); test.ok(emitter.emit('foo.blah'), 'emit should return true after calling a listener'); test.ok(emitter.emit('bar'), 'emit should return true after calling a listener'); test.expect(5); test.done(); } }); EventEmitter2-6.4.7/test/wildcardEvents/all.js000066400000000000000000000150641427200005100212650ustar00rootroot00000000000000var basicEvents = require('nodeunit').testCase; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require('../../lib/eventemitter2').EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } function setHelper (emitter, test, testName){ var eventNames = [ testName, testName + '.*', testName + '.ns1', testName + '.ns1.ns2', testName + '.ns2.*' ]; for (var i = 0; i < eventNames.length; i++) { emitter.on(eventNames[i], function () { test.ok(true, eventNames[i] + 'has fired'); }); } return eventNames; }; module.exports = basicEvents({ '1. An event can be namespaced.': function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); emitter.on('test1.ns1', function () { test.ok(true, 'The event was raised'); }); emitter.emit('test1.ns1'); test.expect(1); test.done(); }, '2. An event can be namespaced and accept values.': function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); emitter.on('test2.ns1', function(value1) { test.ok(true, 'The event was raised'); test.ok(typeof value1 !== 'undefined', 'The event was raised with the value `' + value1 + '`.'); }); emitter.emit('test2.ns1', 1); test.expect(2); test.done(); }, '3. A namespaced event can be raised multiple times and accept values.': function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); emitter.on('test3.ns1', function (value1, value2, value3) { test.ok(true, 'The event was raised'); test.ok(arguments.length === 3, 'The event was raised with the correct number of arguments'); test.ok(value1 === 1 || value1 === 4, 'The event was raised with the value `' + value1 + '`.'); test.ok(value2 === 2 || value2 === 5, 'The event was raised with the value `' + value2 + '`.'); test.ok(value3 === 3 || value3 === 6, 'The event was raised with the value `' + value3 + '`.'); }); emitter.emit('test3.ns1', 1, 2, 3); emitter.emit('test3.ns1', 4, 5, 6); test.expect(10); test.done(); }, '4. A listener should support wild cards.': function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); emitter.on('test4.*', function () { test.ok(true, 'The event was raised'); }); emitter.emit('test4.ns1'); test.expect(1); test.done(); }, '5. Emitting an event should support wildcards.': function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); emitter.on('test5A.test5B', function () { test.ok(true, 'The event was raised'); }); emitter.emit('test5A.*'); test.expect(1); test.done(); }, '6. A listener should support complex wild cards.': function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); emitter.on('test10.*.foo', function () { test.ok(true, 'The event was raised'); }); emitter.emit('test10.ns1.foo'); test.expect(1); test.done(); }, '7. Emitting an event should support complex wildcards.': function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); emitter.on('test11.ns1.foo', function () { test.ok(true, 'The event was raised'); }); emitter.emit('test11.*.foo'); test.expect(1); test.done(); }, '8. Emitting an event should support complex wildcards multiple times, a valid listener should accept values.': function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); emitter.on('test12.ns1.ns2', function (value1, value2, value3) { test.ok(true, 'The event was raised'); test.ok(arguments.length === 3, 'The event was raised with the correct number of arguments'); test.ok(value1 === 1 || value1 === 4, 'The event was raised with the value `' + value1 + '`.'); test.ok(value2 === 2 || value2 === 5, 'The event was raised with the value `' + value1 + '`.'); test.ok(value3 === 3 || value3 === 6, 'The event was raised with the value `' + value1 + '`.'); }); emitter.emit('test12.*.ns2', 1, 2, 3); emitter.emit('test12.*.ns2', 4, 5, 6); test.expect(10); test.done(); }, '9. List all the listeners for a particular event.': function(test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); emitter.on('test13', function (event) { test.ok(true,'raised one'); }); emitter.on('test13', function (event) { test.ok(true,'raised two'); }); var listeners = emitter.listeners('test13'); test.ok(listeners.length === 2, 'The event `test13` should have 2 listeners'); test.expect(1); test.done(); }, '10. should be able to listen on any event with 3 arguments' : function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); var fn = function (event, foo, bar) { test.equal(this.event, 'test23.ns5.ns5') test.equal(event, 'test23.ns5.ns5') test.equal(foo, 'foo'); test.equal(bar, 1); test.ok(true, 'raised test23.ns5.ns5'); } emitter.onAny(fn); emitter.emit('test23.ns5.ns5', 'foo', 1); test.expect(5); test.done(); }, '11. should be able to listen on any event with 4 arguments' : function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); var fn = function (event, foo, bar, baz) { test.equal(this.event, 'test23.ns5.ns5') test.equal(event, 'test23.ns5.ns5') test.equal(foo, 'foo'); test.equal(bar, 1); test.equal(baz, 'baz'); test.ok(true, 'raised test23.ns5.ns5'); } emitter.onAny(fn); emitter.emit('test23.ns5.ns5', 'foo', 1, 'baz'); test.expect(6); test.done(); }, '12. No warning should be raised if we set maxListener to be greater before adding' : function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); var type = 'test29.*'; // set to 20 emitter.setMaxListeners(20); for (var i = 0; i < 15 ; i++) { emitter.on(type, function () { test.ok(true, 'event was raised'); }); } var listeners = emitter.listeners(type); test.equal(listeners.length, 15, 'should have 15'); test.ok(!(emitter.listenerTree[ 'test29' ]['*']._listeners.warned), 'should not have been set'); test.expect(2); test.done(); } }); EventEmitter2-6.4.7/test/wildcardEvents/customDelimiter.js000066400000000000000000000125311427200005100236620ustar00rootroot00000000000000 var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. Add a single listener on a single event.': function (test) { var emitter = new EventEmitter2({ wildcard: true, delimiter: '::' }); var type = 'some::listener::bar'; emitter.on(type, function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners(type).length, 1, 'There are three emitters'); test.expect(1); test.done(); }, '2. Add two listeners on a single event.': function (test) { var emitter = new EventEmitter2({ wildcard: true, delimiter: '::' }); var type = 'some::listener::bar'; emitter.on(type, function () { test.ok(true, 'The event was raised'); }); emitter.on(type, function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners(type).length, 2, 'There are three emitters'); test.expect(1); test.done(); }, '3. Add three listeners on a single event.': function (test) { var emitter = new EventEmitter2({ wildcard: true, delimiter: '::' }); var type = 'some::listener::bar'; emitter.on(type, function () { test.ok(true, 'The event was raised'); }); emitter.on(type, function () { test.ok(true, 'The event was raised'); }); emitter.on(type, function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners(type).length, 3, 'There are three emitters'); test.expect(1); test.done(); }, '4. Add two listeners to two different events.': function (test) { var emitter = new EventEmitter2({ wildcard: true, delimiter: '::' }); var type = 'some::listener::bar'; emitter.on(type, function () { test.ok(true, 'The event was raised'); }); emitter.on(type, function () { test.ok(true, 'The event was raised'); }); emitter.on('test2', function () { test.ok(true, 'The event was raised'); }); emitter.on('test2', function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners(type).length, 2, 'There are two emitters'); test.equal(emitter.listeners('test2').length, 2, 'There are two emitters'); test.expect(2); test.done(); }, '5. Never adding any listeners should yield a listeners array with the length of 0.': function (test) { var emitter = new EventEmitter2({ wildcard: true, delimiter: '::' }); var type = 'some::listener::bar'; emitter.on(type, function () { test.ok(true, 'The event was raised'); }); test.equal(emitter.listeners('test2').length, 0, 'There are no emitters'); test.expect(1); test.done(); }, '6. the listener added should be the right listener.': function (test) { var emitter = new EventEmitter2({ wildcard: true, delimiter: '::' }); var type = 'some::listener::bar'; var f = function () {}; emitter.on(type, f); test.equal(emitter.listeners(type).length, 1, 'There are is one emitters'); test.equal(emitter.listeners(type)[0], f, 'The function should be f'); test.expect(2); test.done(); }, '7. Listeners on *, *::*, *::test with emissions from foo::test and other::emit': function (test) { var emitter = new EventEmitter2({ wildcard: true, delimiter: '::' }); var f = function () { test.ok(true, 'the event was fired') }; emitter.on('*::test', f); emitter.on('*::*', f); emitter.on('*', f); emitter.emit('other::emit'); emitter.emit('foo::test'); test.expect(3); test.done(); }, '8. Listeners on *, *::*, foo.test with emissions from *, *::* and foo.test': function (test) { var emitter = new EventEmitter2({ wildcard: true, delimiter: '::' }); var f = function () { test.ok(true, 'the event was fired') }; emitter.on('foo::test', f); emitter.on('*::*', f); emitter.on('*', f); emitter.emit('*::*'); emitter.emit('foo::test'); emitter.emit('*') test.expect(5); test.done(); }, '9. Listeners on **, **::*, **::test with emissions from foo::test and other::emit': function (test) { var emitter = new EventEmitter2({ wildcard: true, delimiter: '::' }); var f = function () { test.ok(true, 'the event was fired'); }; emitter.on('**::test', f); emitter.on('**::*', f); emitter.on('**', f); emitter.emit('other::emit'); // 2 emitter.emit('foo::test'); // 3 test.expect(5); test.done(); }, '10. Listeners on **, **::*, foo.test with emissions from **, **::* and foo.test': function (test) { var emitter = new EventEmitter2({ wildcard: true, delimiter: '::' }); var i = 0; var f = function (n) { return function() { //console.log(n, this.event); test.ok(true, 'the event was fired'); }; }; emitter.on('foo::test', f(i++)); emitter.on('**::*', f(i++)); emitter.on('**', f(i++)); emitter.emit('**::*'); // 3 emitter.emit('foo::test'); // 3 emitter.emit('**'); // 3 test.expect(9); test.done(); } }); EventEmitter2-6.4.7/test/wildcardEvents/edgeDelimeter.js000066400000000000000000000037401427200005100232520ustar00rootroot00000000000000var simpleEvents = require('nodeunit').testCase; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require('../../lib/eventemitter2').EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. delimeter at the start': function (test) { var emitter = new EventEmitter2({ wildcard: true }); emitter.on('.ns1.ns2', function () { test.ok(true, 'event was raised'); }); emitter.emit('.ns1.ns2'); test.expect(1); test.done(); }, '2. delimeter at the middle': function (test) { var emitter = new EventEmitter2({ wildcard: true }); emitter.on('ns1..ns3', function () { test.ok(true, 'event was raised'); }); emitter.emit('ns1..ns3'); test.expect(1); test.done(); }, '3. delimeter at the end': function (test) { var emitter = new EventEmitter2({ wildcard: true }); emitter.on('ns1.ns2.', function () { test.ok(true, 'event was raised'); }); emitter.emit('ns1.ns2.'); test.expect(1); test.done(); }, '4. custome delimeter at the start': function (test) { var emitter = new EventEmitter2({ wildcard: true, delimeter: '/' }); emitter.on('/ns1/ns2', function () { test.ok(true, 'event was raised'); }); emitter.emit('/ns1/ns2'); test.expect(1); test.done(); }, '5. custome delimeter at the middle': function (test) { var emitter = new EventEmitter2({ wildcard: true, delimeter: '/' }); emitter.on('ns1//ns3', function () { test.ok(true, 'event was raised'); }); emitter.emit('ns1//ns3'); test.expect(1); test.done(); }, '6. custome delimeter at the end': function (test) { var emitter = new EventEmitter2({ wildcard: true }); emitter.on('ns1/ns2/', function () { test.ok(true, 'event was raised'); }); emitter.emit('ns1/ns2/'); test.expect(1); test.done(); } }); EventEmitter2-6.4.7/test/wildcardEvents/eventsNames.js000066400000000000000000000027501427200005100230030ustar00rootroot00000000000000var assert = require('assert'); var file = '../../lib/eventemitter2'; var EventEmitter2; if (typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = { '1. should return wildcard events namespaces': function () { var symbol= Symbol('test'); var ee= new EventEmitter2({ wildcard: true }); var listener; ee.on('a.b.c', function(){}); ee.on('a.b.d', listener= function(){}); ee.on('z.*', function(){}); ee.on(['a', 'b', symbol], function(){}); assert.deepEqual(ee.eventNames(), [ 'z.*', [ 'a', 'b', symbol ], 'a.b.d', 'a.b.c' ]); ee.off('a.b.d', listener); assert.deepEqual(ee.eventNames(), [ 'z.*', [ 'a', 'b', symbol ], 'a.b.c' ]); }, '2. should return wildcard events namespaces as array if asArray option was set': function () { var symbol= Symbol('test'); var ee= new EventEmitter2({ wildcard: true }); var listener; ee.on('a.b.c', function(){}); ee.on('a.b.d', listener= function(){}); ee.on('z.*', function(){}); ee.on(['a', 'b', symbol], function(){}); assert.deepEqual(ee.eventNames(true), [ ['z','*'], [ 'a', 'b', symbol ], ['a','b','d'], ['a','b','c']]); ee.off('a.b.d', listener); assert.deepEqual(ee.eventNames(true), [ ['z','*'], [ 'a', 'b', symbol ], ['a','b','c']]); } }; EventEmitter2-6.4.7/test/wildcardEvents/fix.js000066400000000000000000000017731427200005100213050ustar00rootroot00000000000000var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; var assert= require('assert'); if (typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ 'listeners': { 'should be invoked when also matching exact listener (#278)': function () { const ee = new EventEmitter2({ wildcard: true }); const stack= []; const spy= (id)=> (...args)=> stack.push({id, args}); ee.on('A', spy('A')); ee.on('B.**', spy('B')); ee.on('C', spy('C1')); ee.on('C.**', spy('C2')); ee.emit('A', 'A'); // Logs "A" once ee.emit('B', 'B'); // Logs "B" once ee.emit('C', 'C'); // Logs "C" only once, not matching wildcard C.** assert.deepStrictEqual(stack, [ {id: 'A', args: ['A']}, {id: 'B', args: ['B']}, {id: 'C1', args: ['C']}, {id: 'C2', args: ['C']}, ]); } } }); EventEmitter2-6.4.7/test/wildcardEvents/k1.js000066400000000000000000000036121427200005100210240ustar00rootroot00000000000000 // Copyright Joyent, Inc. and other Node contributors. // // 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. var common = require('../common'); var assert = require('assert'); var EventEmitter = require('../../lib/eventemitter2').EventEmitter2; var e = new EventEmitter({wildcard: true}); var countWildcard = 0; var counMultiLevelWildcard = 0; var countAny = 0; e.on('foo', function() { e.emit('bar', 'bar'); }); e.on('*', function(name) { ++countWildcard; console.log(this.event, name); assert.equal(this.event, name); }); e.on('**', function(name) { ++counMultiLevelWildcard; console.log(this.event, name); assert.equal(this.event, name); }); e.onAny(function(name) { ++countAny; assert.equal(this.event, name); }); e.emit('foo', 'foo'); process.on('exit', function() { assert.equal(countWildcard, 2); assert.equal(counMultiLevelWildcard, 2); assert.equal(countAny, 2); }); EventEmitter2-6.4.7/test/wildcardEvents/normalizeEvent.js000066400000000000000000000045541427200005100235210ustar00rootroot00000000000000var assert= require('assert'); var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports= { 'should normalize event name when emitting an event': function(){ var ee= new EventEmitter2({ wildcard: true }); var counter= 0; ee.on('**', function(){ assert.ok(typeof this.event==='string'); assert.equal(this.event, 'event.test'); counter++; }); ee.emit('event.test'); ee.emit(['event', 'test']); assert.equal(counter, 2, 'event not fired'); }, 'should normalize event name when emitting an event in async mode': function(){ var ee= new EventEmitter2({ wildcard: true }); var counter= 0; ee.on('**', function(){ assert.ok(typeof this.event==='string'); assert.equal(this.event, 'event.test'); counter++; }); return Promise.all([ ee.emitAsync('event.test'), ee.emitAsync(['event', 'test']) ]).then(function(){ assert.equal(counter, 2, 'event not fired'); }); }, 'should not convert ns to a string if ns is an array and contains a symbol': function(){ var ee= new EventEmitter2({ wildcard: true }); var symbol= Symbol('test'); var counter= 0; ee.on('**', function(){ assert.ok(Array.isArray(this.event)); assert.deepEqual(this.event, ['event', symbol]); counter++; }); ee.emit(['event', symbol]); assert.equal(counter, 1, 'event not fired'); }, 'should not convert ns to a string if ns is an array and contains a symbol while emitting in async mode': function(){ var ee= new EventEmitter2({ wildcard: true }); var symbol= Symbol('test'); var counter= 0; ee.on('**', function(){ assert.ok(Array.isArray(this.event)); assert.deepEqual(this.event, ['event', symbol]); counter++; }); return Promise.all([ ee.emit(['event', symbol]) ]).then(function(){ assert.equal(counter, 1, 'event not fired'); }); } }; EventEmitter2-6.4.7/test/wildcardEvents/options.js000066400000000000000000000031271427200005100222050ustar00rootroot00000000000000var basicEvents = require('nodeunit').testCase; var lib = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(lib).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } function setHelper (emitter, test, testName){ var eventNames = [ testName, testName + '.*', testName + '.ns1', testName + '.ns1.ns2', testName + '.ns2.*', testName + '.**', testName = '.ns2.**' ]; for (var i = 0; i < eventNames.length; i++) { emitter.on(eventNames[i], function () { test.ok(true, eventNames[i] + 'has fired'); }); } return eventNames; } module.exports = basicEvents({ 'intialize 1. Configuration Flags Test.': function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); var emitterDefault = new EventEmitter2({ }); test.ok(!emitterDefault.wildcard, 'default .wildcard should be false'); test.ok(emitter.wildcard, '.wildcard should be true when set'); test.expect(2); test.done(); }, 'initialize 2. creating a wildcard EE should have listenerTree.': function (test) { var emitter = new EventEmitter2({ wildcard: true, verbose: true }); var emitterDefault = new EventEmitter2({ }); test.ok(emitter.listenerTree, 'listenerTree should exist'); test.equal(typeof emitter.listenerTree, 'object', 'listenerTree should be an Object'); test.ok(!emitterDefault.listenerTree, 'listenerTree should not exist'); // check the tree to be empty? test.expect(3); test.done(); }, }); EventEmitter2-6.4.7/test/wildcardEvents/prependListener.js000066400000000000000000000012311427200005100236470ustar00rootroot00000000000000var assert= require('assert'); var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports= { 'use prepend on wildcards mode': function(){ var ee = new EventEmitter2({ wildcard: true }); var type = ['some', 'listener', 'bar']; const function1 = function () {} const function2 = function () {} ee.on(type, function2); ee.prependListener(type, function1); assert.deepStrictEqual(ee.listeners(type), [function1, function2]) } }; EventEmitter2-6.4.7/test/wildcardEvents/removeAllListeners.js000066400000000000000000000012571427200005100243330ustar00rootroot00000000000000var assert= require('assert'); var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports= { 'should remove all wildcard events': function(){ var counter=0; var ee= new EventEmitter2({ wildcard: true }); ee.on('test.*', function(){ counter++; }); assert.equal(ee.listenerCount('test.*'), 1); ee.emit('test.foo'); assert.equal(counter, 1); ee.removeAllListeners(); assert.equal(ee.listenerCount('test.*'), 0); } }; EventEmitter2-6.4.7/test/wildcardEvents/removeListener.js000066400000000000000000000177131427200005100235230ustar00rootroot00000000000000var simpleEvents= require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. add a single event and then remove the event.' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'remove.foo.bar', listeners; var f = function () { test.ok(true, 'event was raised'); }; emitter.on(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 1, 'should only have 1'); //remove emitter.removeListener(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 0, 'should be 0'); test.expect(2); test.done(); }, '2. Add two events and then remove only one of those events.' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'remove.foo.bar', listeners; var f = function f() { test.ok(true, 'event was raised'); }; emitter.on(type, f); emitter.on(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 2, 'should only have 2'); emitter.removeListener(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 1, 'should be 1'); test.expect(2); test.done(); }, '3. Add three events and remove only one of the events that was added.' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'remove.foo.bar', listeners; var f = function () { test.ok(true, 'event was raised'); }; emitter.on(type, f); emitter.on(type, f); emitter.on(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 3, 'should only have 3'); //remove emitter.removeListener(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 2, 'should be 2'); test.expect(2); test.done(); }, '4. Should error if we don\'t pass a function to the emit method.' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'remove.foo.bar', listeners; var f = function () { test.ok(true, 'event was raised'); }; emitter.on(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 1, 'should only have 1'); //remove test.throws(function () {emitter.removeListener(type, type)}, Error, 'should throw an Error'); listeners = emitter.listeners(type); test.equal(listeners.length, 1, 'should be 1'); test.expect(3); test.done(); }, '5. Removing one listener should not affect another listener.' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'remove.foo.bar', listeners; var f = function () { test.ok(true, 'event was raised'); }; var g = function () { test.ok(true, 'event was raised'); }; emitter.on(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 1, 'should only have 1'); //remove emitter.removeListener(type, g); listeners = emitter.listeners(type); test.equal(listeners.length, 1, 'should be 1'); test.expect(2); test.done(); }, '6. Remove all listener functions.' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'remove.foo.bar', listeners; var f = function () { test.ok(true, 'event was raised'); }; for (var i = 0; i < 10; i++) { emitter.on(type, f); } listeners = emitter.listeners(type); test.equal(listeners.length, 10, 'should only have 10'); emitter.removeListener(type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 9, 'should be 9'); emitter.removeAllListeners(type); listeners = emitter.listeners(type); test.equal(listeners.length, 0, 'should be 0'); test.expect(3); test.done(); }, '7. Removing listeners for one event should not affect another event\'s listeners.' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'remove.foo.bar'; var listeners; var f = function () { test.ok(true, 'event was raised'); }; for (var i = 0; i < 10; i++) { emitter.on(type, f); } listeners = emitter.listeners(type); test.equal(listeners.length, 10, 'should only have 10'); emitter.removeListener(type+type, f); listeners = emitter.listeners(type); test.equal(listeners.length, 10, 'should be 10'); emitter.removeAllListeners(type+type); listeners = emitter.listeners(type); test.equal(listeners.length, 10, 'should be 10'); emitter.removeAllListeners(type+'.'+type); listeners = emitter.listeners(type); test.equal(listeners.length, 10, 'should be 10'); emitter.removeAllListeners(type); listeners = emitter.listeners(type); test.equal(listeners.length, 0, 'should be 0'); test.expect(5); test.done(); }, '8. Its ok to listen on wildcard, so it is ok to remove it.' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type1 = '*.wild.card', type2 = 'just.another.event', listeners; var f = function () { test.ok(true, 'event was raised'); }; emitter.on(type2, f); emitter.on(type1, f); //remove emitter.removeListener(type1, f); listeners = emitter.listeners(type1); test.equal(listeners.length, 0, 'should be 0'); test.expect(1); test.done(); }, '9. And (8) should not depend on order of listening.' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type1 = '*.wild.card', type2 = 'just.another.event', listeners; var f = function () { test.ok(true, 'event was raised'); }; emitter.on(type1, f); emitter.on(type2, f); //remove emitter.removeListener(type1, f); listeners = emitter.listeners(type1); test.equal(listeners.length, 0, 'should be 0'); test.expect(1); test.done(); }, '10. Reporting many listeners on wildcard all should removed.' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type1 = '*.wild.card', type2 = 'exact.wild.card', listeners; var f = function () { test.ok(true, 'event was raised'); }; emitter.on(type1, f); emitter.on(type2, f); // check number of listeners by wild card listeners = emitter.listeners(type1); test.equal(listeners.length, 2, 'should only have 2'); // remove by wild card should remove both emitter.removeListener(type1, f); listeners = emitter.listeners(type1); test.equal(listeners.length, 0, 'should be 0'); test.expect(2); test.done(); }, '11. Add some listeners with wildcards and remove only the wildcard' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var count = 0; var goodCallback = function () { count += 1; }; var badCallback = function () { count += 1; }; // So that foo.bar.listeners is an Array emitter.on("foo.bar.baz", goodCallback); emitter.on("foo.bar.baz", goodCallback); // Add and remove one with wildcard emitter.on("foo.*.*", badCallback); var returnValue = emitter.off("foo.*.*", badCallback); emitter.emit("foo.bar.baz"); test.equal(count, 2, 'should call only good callbacks'); test.equal(returnValue, emitter, 'should allow chaining'); test.expect(2); test.done(); } }); EventEmitter2-6.4.7/test/wildcardEvents/ttl.js000066400000000000000000000113431427200005100213140ustar00rootroot00000000000000var simpleEvents = require('nodeunit').testCase; var file = '../../lib/eventemitter2'; var EventEmitter2; if(typeof require !== 'undefined') { EventEmitter2 = require(file).EventEmitter2; } else { EventEmitter2 = window.EventEmitter2; } module.exports = simpleEvents({ '1. A listener added with `once` should only listen once and then be removed.': function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'test1.foo.bar'; emitter.once(type, function () { test.ok(true, 'The event was raised once'); }); emitter.emit(type); emitter.emit(type); test.expect(1); test.done(); }, '2. A listener with a TTL of 4 should only listen 4 times.': function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'test1.foo.bar'; emitter.many(type, 4, function (value1) { test.ok(true, 'The event was raised 4 times.'); }); emitter.emit(type, 1); emitter.emit(type, 2); emitter.emit(type, 3); emitter.emit(type, 4); emitter.emit(type, 5); test.expect(4); test.done(); }, '3. A listener with a TTL of 4 should only listen 4 times and pass parameters.': function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'test1.foo.bar'; emitter.many(type, 4, function (value1, value2, value3) { test.ok(typeof value1 !== 'undefined', 'got value 1'); test.ok(typeof value2 !== 'undefined', 'got value 2'); test.ok(typeof value3 !== 'undefined', 'got value 3'); }); emitter.emit(type, 1, 'A', false); emitter.emit(type, 2, 'A', false); emitter.emit(type, 3, 'A', false); emitter.emit(type, 4, 'A', false); emitter.emit(type, 5, 'A', false); test.done(); }, '4. Remove an event listener by signature.': function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'test1.foo.bar'; var count = 0; function f1(event) { "event A"; test.ok(true, 'The event was raised less than 3 times.'); } emitter.on(type, f1); function f2(event) { "event B"; test.ok(true, 'The event was raised less than 3 times.'); } emitter.on(type, f2); function f3(event) { "event C"; test.ok(true, 'The event was raised less than 3 times.'); } emitter.on(type, f3); emitter.removeListener(type, f2); emitter.emit(type); test.expect(2); test.done(); }, '5. `removeListener` and `once`': function(test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'test1.foo.bar'; var functionA = function() { test.ok(true, 'Event was fired'); }; emitter.once(type, functionA); emitter.removeListener(type, functionA); emitter.emit(type); test.expect(0); test.done(); }, '6. Listening with a wildcard on once' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'test1.foo.*'; var functionA = function() { test.ok(true, 'Event was fired'); }; emitter.once(type, functionA); emitter.on(type,functionA); emitter.emit(type); //2 emitter.emit(type); //1 test.expect(3); test.done(); }, '7. Emitting with a wildcard targeted at once' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'test1.foo.bar'; var type2 = 'test1.foo.*'; var functionA = function() { test.ok(true, 'Event was fired'); }; emitter.once(type, functionA); emitter.emit(type2); emitter.emit(type2); test.expect(1); test.done(); }, '8. Emitting with a multi-level wildcard on once': function(test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var i = 0; var type = 'test1.**'; var functionA = function(n) { return function() { console.log(n, this.event); test.ok(true, 'Event was fired'); }; } emitter.once(type, functionA(i++)); emitter.on(type, functionA(i++)); emitter.emit(type); //2 emitter.emit(type); //1 test.expect(3); test.done(); }, '9. Emitting with a multi-level wildcard targeted at once' : function (test) { var emitter = new EventEmitter2({ wildcard : true, verbose : true }); var type = 'test1.foo.bar'; var type2 = 'test1.**'; var functionA = function() { test.ok(true, 'Event was fired'); }; emitter.once(type, functionA); emitter.emit(type2); emitter.emit(type2); test.expect(1); test.done(); } });