• Public
  • Public/Protected
  • All


Code checks: Build Status Maintainability Test Coverage

Package infos: npm npm version license Commitizen friendly Greenkeeper badge

See the API documentation on github.io/sequential-event

This library is a variation of standard event emitters. Handlers are executed sequentialy, and may return Promises if it executes asynchronous code.

For usage in the browser, use the files in the dist directory

Example usage

const SequentialEvent = require( 'sequential-event' );

function sampleTime( startTime ) {
    return new Date().getTime() - startTime;
const eventEmitter = new SequentialEvent();

// We create a new array with a new timer
eventEmitter.on( 'retime', startTime => {
    return [ sampleTime( startTime ) ];
// We wait 100ms and we re-time
eventEmitter.on( 'retime', ( startTime, timers ) => {
    // This operation is async, so we return a Promise that will be resolved
    // with the timers array
    return new Promise(( resolve ) => {
        setTimeout(() => {
            timers.push( sampleTime( startTime ));
            return resolve( timers );
        }, 100 );
// We re-take a sample immediatly
eventEmitter.on( 'retime', ( startTime, timers ) => {
    // This operation is sync, so we can return our timers array directly
    timers.push( sampleTime( startTime ));
    return timers;

    // Emit our retime event with the current date
    .emit( 'retime', new Date().getTime())
    // Log normaly if everything is OK, or log with error
    .then( timers => console.log( timers ))
    .catch( err => console.error( err ));

Here is an example of output of this code:

[ 1, 109, 109 ]

You can see that each on handlers are executed sequentially, after the end of the previous handler.



Triggers all listeners of the provided events, spraying params to each callbacks. Returned or resolved values from callbacks (if returning a Promise) are passed as last parameter of the next callback function.


emit(string eventName[, ...any params]) => Promise(any)


Remove callbacks from events.


off(object events ) => this

// Remove all listeners
// Remove all listeners on 'eventFoo'
eventListener.off( 'eventFoo' );
// Remove `cb` from 'eventFoo'
eventListener.off( 'eventFoo', cb );
// Remove `cbFoo` from 'event1' and `cbBar` from 'event2'
    event1: cbFoo,
    event2: cbBar,


Bind callbacks to specified events. The callback will be executable a single time for each event.


once(string eventName, function callback) => this

once(object events ) => this

// Attach the same callback to `event1` & `event2`. `event1` callback may be
// executed a single time, as `event2`.
eventListener.once( 'event1 event2', () => Promise.resolve( 'foo' ));
// Bind a callback that returns 'foo' on `event1`, and 'bar' on `event2`. Both
// will be run a single time.
    event1: () => Promise.resolve( 'foo' ),
    event2: () => Promise.resolve( 'bar' ),


Attach callbacks to specified events.


on(string eventName, function callback) => this

on(object events ) => this

// Attach the same callback to `event1` & `event2`
eventListener.on( 'event1 event2', () => Promise.resolve( 'foo' ));
// Bind a callback that returns 'foo' on `event1`, and 'bar' on `event2`
    event1: () => Promise.resolve( 'foo' ),
    event2: () => Promise.resolve( 'bar' ),


This package can run on:

  • Node >= 6.0.0
  • Most modern browsers

NPM scripts

  • npm t: Run test suite
  • npm start: Run npm run build in watch mode
  • npm run test:watch: Run test suite in interactive watch mode
  • npm run test:prod: Run linting and generate coverage
  • npm run build: Generate bundles and typings, create docs
  • npm run lint: Lints code
  • npm run commit: Commit using conventional commit style (husky will tell you to use it if you haven't :wink:)



Const addEventListener

Const castArgsToEventsHash

Const emitHandler

Const emitHandlers

Const ensureArray

  • ensureArray<T>(data: T | T[]): T[]
  • Ensure that event & callback are on the associative hash format.

    Type parameters

    • T


    • data: T | T[]

    Returns T[]

Const forEachObj

  • forEachObj<T>(object: object, callback: function): void
  • Type parameters

    • T


    • object: object
      • [key: string]: T
    • callback: function
        • (value: T, key: string): any
        • Parameters

          • value: T
          • key: string

          Returns any

    Returns void

Const getNextPromise

  • Generate next promise for sequence.


    Returns function

      • (resolve: Function, reject: function): Function
      • Parameters

        • resolve: Function
        • reject: function
            • (reason: any): any
            • Parameters

              • reason: any

              Returns any

        Returns Function

Const onceify

  • Generate an event handler that deregister itself when executed. This handler will be executed just once.


    • target: SequentialEvent

      Event emitter that will use the handler.

    • eventName: string

      Name of the event to trigger.

    • eventFn: IEventHandler

      Handler for the event.

    Returns IOnceHandler

    Function that will be executed only once.

Const removeEventListener

Const removeSingleListener


  • Module
  • Object literal
  • Variable
  • Function
  • Function with type parameter
  • Index signature
  • Type alias
  • Enumeration
  • Enumeration member
  • Property
  • Method
  • Interface
  • Interface with type parameter
  • Constructor
  • Property
  • Method
  • Index signature
  • Class
  • Class with type parameter
  • Constructor
  • Property
  • Method
  • Accessor
  • Index signature
  • Inherited constructor
  • Inherited property
  • Inherited method
  • Inherited accessor
  • Protected property
  • Protected method
  • Protected accessor
  • Private property
  • Private method
  • Private accessor
  • Static property
  • Static method

Generated using TypeDoc