Displaying 1 to 18 from 18 results

on-change - Watch an object or array for changes

It works recursively, so it will even detect if you modify a deep property like obj.a.b[0].c = true.Uses the Proxy API.

emittery - Simple and modern async event emitter

It's only ~200 bytes minified and gzipped. I'm not fanatic about keeping the size at this level though.Emitting events asynchronously is important for production code where you want the least amount of synchronous operations.

Ajax Exception Logging

The purpose of this project is to provide an effective Error Logging System for Client Side which supports multiple trace listeners.


It is a pocket executable which includes a trace listener and monitor . Trace listener sends data to monitor using Udp multicast channel.

hub.js - The most advanced EventEmitter for Node and the browser

The most advanced EventEmitter for Node and the browser.Use Browserify to create a standalone file.

p-event - Promisify an event by waiting for it to be emitted

Useful when you need only one event emission and want to use it with promises or await it in an async function.If you want multiple individual events as they are emitted, this module is not for you, as a Promise is a single value. Instead, just continue using event callback or use Observables.

good-listener - A more versatile way of adding & removing event listeners

A more versatile way of adding & removing event listeners. You can get it on npm.

midi-eye - Ruby MIDI input event listener

The listener will try to positively match the parameters you pass in to the properties of the messages it receives. In this example, we specify that the listener listens for note on/off messages, which are identifiable by their class.

idempotent-bind - idempotent bind function library.

idempotent bind function library. ECMAScript' Function.prototype.bind (thisArg [, arg1 [, arg2, …]]) is not idempotent.

Flask-Validator - Validator for SQLAlchemy Models

Data validator for Flask using SQL-Alchemy, working at Model component with events, preventing invalid data in the columns. The extension works with event listeners from SQLAlchemy. The most performant way to set up your validations is during the SQLAlchemy special directive_ __declare_last__, it occurs after mappings are assumed to be completed and the 'configure' step has finished.

eev - A tiny, fast, zero-dependency event emitter

A tiny, fast, zero-dependency event emitter for JavaScript. Create an Eev instance.

ObjectEventTarget - A same behaviour EventTarget prototype, that can work with any object from JavaScript

You know as everybody knows how to use the EventTarget today, because every Node instance (HTML Elements) prototype it. And that's make it awesome. You can prototype your objects with this and you will have support to events. Also it can be used as prototype of a shim to EventTarget in non-modern browsers. Because it's compatible with ES3.

soma-events - Event shim and dispatcher to use the DOM 3 event syntax everywhere

Event shim and dispatcher to use the DOM 3 event syntax everywhere. One of the core aspect of writing a maintainable and scalable code is to decouple the modules of your application so they are not tied together. If a module can't "talk" directly to another, you will need to find a way to notify other elements, this is called an Observer Pattern.

lapidus - Stream your PostgreSQL, MySQL or MongoDB databases anywhere, fast.

Currently MySQL and PostgreSQL databases are fully supported. MongoDB supports inserts and deletes, however, updates return a copy of the operation (for example, a $rename operation will return a $set for the new field and an $unset for the old field) instead of the object as it exists in the database. Redis support is on the way. Lapidus can currently be used as a daemon or Node.js module. Support for piping line-delimited JSON to other processes is a high priority. You'll need PostgreSQL 9.4 or higher with logical replication configured and the JSONCDC plugin installed and loaded. Any PostgreSQL fork that ships with pg_recvlogical should be compatible.


There are times when it's necessary to monkeypatch default behavior in JavaScript and Node. However, changing the behavior of the runtime on the fly is rarely a good idea, and you should be using this module because you need to, not because it seems like fun. Wrap an EventEmitter's event listeners. Each listener will be passed to mark when it is registered with .addListener() or .on(), and then each listener is passed to prepare to be wrapped before it's called by the .emit() call. wrapListener deals with the single listener vs array of listeners logic, and also ensures that edge cases like .removeListener() being called from within an .emit() for the same event type is handled properly.