npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

event-io

v0.1.10

Published

ES6 class that combines an event acceptor and emitter.

Downloads

8

Readme

event-io

An ES6 class that combines an event emitter, an event acceptor, and runtime type checking. Can be used to design purely event-driven classes, rather than just event-producing as is the case with node's built-in EventEmitter.

This implementation does not require node's EventEmitter interface.

Install

npm install event-io

Usage

The library exports the EventIO class, which is intended to be inherited from. This exposes the setAcceptHandlers method, which maps event names to the function that will be invoked on accept() calls. Multiple calls to setAcceptHandlers will be additive, i.e., previous handlers are not removed.

const EventIO = require('event-io');

class MyClass extends EventIO {
  constructor() {
    super();
    this.setAcceptHandlers({
      event_type_1 (...evtArgs, cb) {
        // handle incoming event of type "event_type_1" by emitting
        // an event of type "event_type_2" synchronously.
        this.emit('event_type_2', ...evtArgs);
      },
      event_type_2 (...evtArgs) {
        this.emit('event_type_3', true);
      }
    });
  }
}

Add an accept and emit schema to the class. See the runtype npm package for details on the format of schemas.

MyClass.prototype.$schema = {
  accept: {
    event_type_1: [
      // type definition of first argument
      {
        type: 'string'
      },
      // type definition of second argument
      {
        type: 'integer'
      }
    ]
  },
  emit: {
    event_type_2: [
      // type definition of first argument
      {
        type: 'string'
      },
      // type definition of second argument
      {
        type: 'integer'
      }
    ],
    event_type_3: [
      // type definition of first argument
      {
        type: 'boolean'
      }
    ]
  }
};

To use an instance of the class.

const inst = new MyClass();
inst.accept('event_type_1', 'first_arg', 3);

This will invoke the event_type_1 handler function with an evtArgs value of ['first_arg', 3]. The this context of the function call will be the instance of the class, i.e., inst in the example above.

All calls to accept() and emit() will be type-checked according to the schema, and exceptions thrown if the schema does not match. accept() and emit() are both synchronous functions, which means that emit listeners will be invoked immediately (without waiting for the next tick).

To listen to events being emitted from inst, use the functions on, once, and upto to register event listeners, and removeListener and removeAllListeners to remove them.

Error Handling

Runtime type checks will catch values passed to emit and accept that do not match the specified schema. Exceptions are thrown immediately, which means that calls to emit and accept should always be wrapped in try...catch blocks.

The caught exception will contain the following fields.

  • message (string): Human-readable description of error.
  • eventName (string): Event name that was supplied for emit.