Big refactoring with better types, ES2015+ and smaller size

Author: ai

.gitignore

@@ -2,4 +2,3 @@ node_modules/
 yarn-error.log
 
 coverage/
-api.md

README.md

@@ -2,16 +2,18 @@
 
 Simple and tiny event emitter library for JavaScript.
 
-* Only **103 bytes** (minified and gzipped).
+* Only **78 bytes** (minified and gzipped).
   It uses [Size Limit] to control size.
 * `on` method returns `unbind` function. You don’t need to save
   callback to variable for `removeListener`.
+* TypeScript and ES modules support.
 * No aliases, just `emit` and `on` methods.
   No Node.js [EventEmitter] compatibility.
 
 ```js
-import NanoEvents from 'nanoevents'
-const emitter = new NanoEvents()
+const createNanoEvents = require('nanoevents')
+
+const emitter = createNanoEvents()
 
 const unbind = emitter.on('tick', volume => {
   summary += volume
@@ -34,17 +36,69 @@ summary //=> 2
 </a>
 
 
-## Usage
+## Table of Contents
+
+* [TypeScript](#typescript)
+* [ES Modules](#es-modules)
+* [Mixing to Object](#mixing-to-object)
+* [Add Listener](#add-listener)
+* [Remove Listener](#remove-listener)
+* [Execute Listeners](#execute-listeners)
+* [Events List](#events-list)
+* [Once](#once)
+* [Remove All Listeners](#remove-all-listeners)
+
+
+## TypeScript
+
+Nano Events accepts interface with event name
+to listener argument types mapping.
+
+```ts
+import createNanoEvents = require('..')
+
+interface Events {
+  'set': (name: string, count: number) => void,
+  'tick': () => void
+}
+
+const emitter = createNanoEvents<Events>()
+
+// Correct calls:
+emitter.emit('set', 'prop', 1)
+emitter.emit('tick')
+
+// Compilation errors:
+emitter.emit('set', 'prop', '1')
+emitter.emit('tick', 2)
+```
+
 
-### Mixing to Object
+## ES Modules
+
+In Node.js 13 you can import ES module by manually added `index.mjs`.
+
+```js
+import createNanoEvents from 'nanoevents/index.mjs'
+```
+
+For quick hacks you can load Nano Events from CDN. Do not use it in production
+because of low performance.
+
+```js
+import createNanoEvents from 'https://cdn.jsdelivr.net/npm/nanoevents/index.mjs'
+```
+
+
+## Mixing to Object
 
 Because Nano Events API has only just 2 methods,
 you could just create proxy methods in your class.
 
 ```js
 class Ticker {
   constructor() {
-    this.emitter = new NanoEvents()
+    this.emitter = createNanoEvents()
   }
   on() {
     return this.emitter.on.apply(this.emitter, arguments)
@@ -55,10 +109,8 @@ class Ticker {
 }
 ```
 
-It allows you to have custom JSDoc or type definitions.
 
-
-### Add Listener
+## Add Listener
 
 Use `on` method to add listener for specific event:
 
@@ -93,7 +145,7 @@ Note: binding with use of the `.bind()` method won’t work as you might expect
 and therefore is not recommended.
 
 
-### Remove Listener
+## Remove Listener
 
 Methods `on` returns `unbind` function. Call it and this listener
 will be removed from event.
@@ -112,7 +164,7 @@ emitter.emit('tick', 2)
 ```
 
 
-### Execute Listeners
+## Execute Listeners
 
 Method `emit` will execute all listeners. First argument is event name, others
 will be passed to listeners.
@@ -126,7 +178,7 @@ emitter.emit('tick', 1, 'one')
 ```
 
 
-### Events List
+## Events List
 
 You can get used events list by `events` property.
 
@@ -136,15 +188,15 @@ emitter.events //=> { tick: [ [Function] ] }
 ```
 
 
-### Once
+## Once
 
 If you need add event listener only for first event dispatch,
 you can use this snippet:
 
 ```js
 class Ticker {
   constructor() {
-    this.emitter = new NanoEvents()
+    this.emitter = createNanoEvents()
   }
   …
   once (event, callback) {
@@ -157,17 +209,12 @@ class Ticker {
 }
 ```
 
-### Remove all listeners
 
-`unbindAll` method will remove all listeners to all events.
+## Remove All Listeners
 
 ```js
-import unbindAll from 'nanoevents/unbind-all';
-
 emitter.on('event1', () => { })
 emitter.on('event2', () => { })
 
-unbindAll(emitter);
-
-Object.keys(emitter.events) //=> { }
+emitter.events = { }
 ```

index.d.ts

@@ -0,0 +1,77 @@
+interface EventsMap {
+  [event: string]: any
+}
+
+interface DefaultEvents extends EventsMap {
+  [event: string]: (...args: any) => void
+}
+
+declare class Emitter<Events extends EventsMap> {
+  /**
+   * Event names in keys and arrays with listeners in values.
+   *
+   * ```js
+   * emitter1.events = emitter2.events
+   * emitter2.events = { }
+   * ```
+   */
+  events: Partial<{ [E in keyof Events]: Events[E][] }>
+
+  /**
+   * Add a listener for a given event.
+   *
+   * ```js
+   * const unbind = ee.on('tick', (tickType, tickDuration) => {
+   *   count += 1
+   * })
+   *
+   * disable () {
+   *   unbind()
+   * }
+   * ```
+   *
+   * @param event The event name.
+   * @param cb The listener function.
+   * @returns Unbind listener from event.
+   */
+  on <K extends keyof Events>(event: K, cb: Events[K]): () => void
+
+  /**
+   * Calls each of the listeners registered for a given event.
+   *
+   * ```js
+   * ee.emit('tick', tickType, tickDuration)
+   * ```
+   *
+   * @param event The event name.
+   * @param args The arguments for listeners.
+   */
+  emit <K extends keyof Events>(
+    event: K,
+    ...args: Parameters<Events[K]>
+  ): void
+}
+
+/**
+ * Create event emitter.
+ *
+ * ```js
+ * import createNanoEvents from 'nanoevents'
+ *
+ * class Ticker {
+ *   constructor() {
+ *     this.emitter = createNanoEvents()
+ *   }
+ *   on(...args) {
+ *     return this.emitter.on(...args)
+ *   }
+ *   tick() {
+ *     this.emitter.emit('tick')
+ *   }
+ * }
+ * ```
+ */
+declare function createNanoEvents<Events extends EventsMap = DefaultEvents> (
+): Emitter<Events>
+
+export = createNanoEvents

index.js

@@ -1,92 +1,18 @@
-(
-  /**
-   * Interface for event subscription.
-   *
-   * @example
-   * var NanoEvents = require('nanoevents')
-   *
-   * class Ticker {
-   *   constructor() {
-   *     this.emitter = new NanoEvents()
-   *   }
-   *   on() {
-   *     return this.emitter.on.apply(this.events, arguments)
-   *   }
-   *   tick() {
-   *     this.emitter.emit('tick')
-   *   }
-   * }
-   *
-   * @alias NanoEvents
-   * @class
-   */
-  module.exports = function NanoEvents () {
-    /**
-     * Event names in keys and arrays with listeners in values.
-     * @type {object}
-     *
-     * @example
-     * Object.keys(ee.events)
-     *
-     * @alias NanoEvents#events
-     */
-    this.events = { }
+module.exports = function () {
+  let emitter = {
+    events: { }
   }
-).prototype = {
 
-  /**
-   * Calls each of the listeners registered for a given event.
-   *
-   * @param {string} event The event name.
-   * @param {...*} arguments The arguments for listeners.
-   *
-   * @return {undefined}
-   *
-   * @example
-   * ee.emit('tick', tickType, tickDuration)
-   *
-   * @alias NanoEvents#emit
-   * @method
-   */
-  emit: function emit (event) {
-    var args = [].slice.call(arguments, 1)
-    // Array.prototype.call() returns empty array if context is not array-like
-    ;[].slice.call(this.events[event] || []).filter(function (i) {
-      i.apply(null, args)
-    })
-  },
-
-  /**
-   * Add a listener for a given event.
-   *
-   * @param {string} event The event name.
-   * @param {function} cb The listener function.
-   *
-   * @return {function} Unbind listener from event.
-   *
-   * @example
-   * const unbind = ee.on('tick', (tickType, tickDuration) => {
-   *   count += 1
-   * })
-   *
-   * disable () {
-   *   unbind()
-   * }
-   *
-   * @alias NanoEvents#on
-   * @method
-   */
-  on: function on (event, cb) {
-    if (process.env.NODE_ENV !== 'production' && typeof cb !== 'function') {
-      throw new Error('Listener must be a function')
-    }
-
-    (this.events[event] = this.events[event] || []).push(cb)
+  emitter.emit = (event, ...args) => {
+    (emitter.events[event] || []).filter(i => i(...args))
+  }
 
+  emitter.on = (event, cb) => {
+    (emitter.events[event] = emitter.events[event] || []).push(cb)
     return function () {
-      this.events[event] = this.events[event].filter(function (i) {
-        return i !== cb
-      })
-    }.bind(this)
+      emitter.events[event] = emitter.events[event].filter(i => i !== cb)
+    }
   }
+
+  return emitter
 }