Skip to main content
100%

Do we really need an event emitter?

✓ Published0🌍 Public
Aamundo
Last edited Nov 2, 2014
Created on Nov 2, 2014

This example shows how to replace event-emitter libraries like WildEmitter with native browser APIs. It defines a Vocab model that dispatches a custom `addToVocab` event via `dispatchEvent(new CustomEvent(...))` on the global `window` object, and a VocabView that listens with `addEventListener`. The code demonstrates that `addEventListener` and `dispatchEvent` work globally without needing an emitter instance, using only vanilla JavaScript and DOM events.

AI-generated description

Similar vizzes

Loading thumbnail…

Cross-browsers events listener implementation

This example shows a cross-browser event listener abstraction that normalizes how JavaScript attaches and removes DOM event handlers. The code defines an `addListener` and `removeListener` pair, then initializes them by detecting the available API at runtime. It uses the standard `window.addEventListener` and `removeEventListener` methods when supported, falls back to Internet Explorer’s `document.attachEvent` and `detachEvent` with an `'on'` prefix, and finally uses direct `el['on' + type]` property assignment for older browsers. The logic is contained in a single self-invoking object that returns itself, ready for use without any external libraries.

Aabernier
60% match
Loading thumbnail…

Hello Reactor

This example demonstrates a minimal event-driven communication system built with JavaScript. It shows how two listeners attached to the same `'big bang'` event respond to a dispatched payload, with one listener logging a fixed message and the other printing the passed arguments. The code defines a custom `Reactor` class and an `Event` class, showcasing manual event registration, callback storage, and dispatch logic. The implementation relies on JavaScript's array `forEach` method to invoke all registered callbacks with the spread `...eventArgs` syntax. The data originates from a hardcoded dispatch call passing the values `135`, `'test'`, and `[1, 2, 3]`.

MMAKIO135
56% match
Loading thumbnail…

Gist d51a566a307b428d98eaf3aa8d2a59a3

This example benchmarks JavaScript event emitter libraries across multiple test scenarios, including initialization, emitting with context, and emitting single or multiple values to one or more listeners. The code runs benchmark suites using `benchmark.js`, comparing libraries such as `EventEmitter3`, `MiniSignals`, `push-stream`, and `signal-lite`, and reports throughput in operations per second. It highlights the fastest performers per scenario, such as `push-stream` leading in the "emit with context" test. The visualization shows raw performance data from Node.js 6.2.1, rendered as plain-text tables with pass/fail assertions and timing summaries.

HHypercubed
56% match
Loading thumbnail…

intercept *.addEventListener for debugging

This example demonstrates how to intercept and log every `addEventListener` call on HTML element prototypes for debugging purposes. It enumerates all `HTML*` interfaces from `window`, then wraps each prototype’s `addEventListener` method to print the event type, listener, and `useCapture` flag, followed by a stack trace via `console.trace()`. The code uses native browser APIs like `Object.getOwnPropertyNames`, `window`, and prototype manipulation, with no external libraries, and is based on a Stack Overflow solution adapted for Firefox.

Aalessioalex
51% match
Loading thumbnail…

[React Native + RxJS] Create an Observable from DeviceEventEmitter - An example to handle 'locationUpdated' event

This example demonstrates how to create an RxJS Observable from React Native’s `DeviceEventEmitter`, enabling reactive handling of the `locationUpdated` event from the `react-native-location` library. It shows the full flow: a factory function wraps `DeviceEventEmitter.addListener` via `Observable.fromEventPattern`, then a second observable applies `.throttle` to limit event frequency and maps raw location coordinates into a simple object. Finally, a subscription logs the transformed location data, with explicit unsubscribe support via `subscription.dispose()`.

Aalex-milanov
51% match
Loading thumbnail…

An eventing mechanism for Swift

This example demonstrates an eventing mechanism for Swift, showing how to create type-safe events with multiple handlers and automatic cleanup. It defines an `Event<T>` class that manages a collection of handler wrappers, allowing observers to subscribe and unsubscribe dynamically. The implementation uses the `Disposable` protocol for tear-down logic and the `Invocable` private protocol to abstract handler invocation, with `EventHandlerWrapper` holding a weak reference to the target to prevent retain cycles. The code highlights Swift’s protocol-oriented and generics features, as well as curried instance methods, to build a reusable notification system without relying on external libraries.

CColinEberhardt
51% match
Loading thumbnail…

EventsSpeedTests emit objects

The visualization compares JavaScript event emitter libraries by plotting operations-per-second benchmarks from Chrome 50 and Node.js 6.1.0, using a horizontal bar chart. Each bar’s length represents throughput, with a dashed line marking the theoretical maximum. The code uses a custom rendering approach with the Canvas API and `requestAnimationFrame` to draw bars, while data is parsed from the gist’s markdown tables. This highlights MiniSignals as the fastest emitter in both environments, outperforming EventEmitter3 and ReactiveProperty.

HHypercubed
51% match
Loading thumbnail…

simple buzzPost listener

This example demonstrates a minimal event-listener setup that subscribes to a live message stream and logs each incoming event to the browser console. It shows how a single JavaScript file can establish a real-time connection to a remote hub using the native EventSource API, which handles the server-sent events protocol. The code defines a fixed channel list—alfa, bravo, and charlie—via the URL string, then attaches an `onmessage` handler to print every message object as it arrives. No visualization or data transformation occurs; the focus is purely on the listening and logging mechanism.

Aandrew-psch
51% match