rocket-connect/for-emit-of

Turn Node.js Events into Async Iterables.

for-emit-of

Turn Node.js Events into Async Iterables.

$ npm install for-emit-of

• Example
• Transform
• Change the event
• Change the end
• Timeout
  • firstEventTimeout
  • inBetweenTimeout
• Limit
• Debug
• Keep Alive

Example

import forEmitOf from 'for-emit-of';
import { Emitter } from '..'; // Example

const iterator = forEmitOf(Emitter, {
    event: "data", // Default
});

for await (const event of iterator){
    // Do Something 
}

Equivalent to

Emitter.on("data", () => {});

Transform

import forEmitOf from 'for-emit-of';
import { Emitter } from '..';

const iterator = forEmitOf(Emitter, {
    transform: async (event) => { // async aware
        return JSON.stringify(event);
    }
});

for await (const event of iterator){
    // Stringy
}

Equivalent to

Emitter.on("data", (event) => {
    const stringy = JSON.stringify(event);
});

Change the event

import forEmitOf from 'for-emit-of';
import { Cart } from '..';

const iterator = forEmitOf(Cart, {
    event: "checkout"
});

for await (const order of iterator){
    // Do Something 
}

Equivalent to

Cart.on("checkout", (order) => { ... });

Change the end

import forEmitOf from 'for-emit-of';
import { Cart } from '..';

const iterator = forEmitOf(Cart, {
    end: ["end", "close"] // default
});

Timeout

firstEventTimeout

import forEmitOf from 'for-emit-of';
import { EventEmitter } from "events";

const emitter = new EventEmitter();

const iterator = forEmitOf(emitter, {
  firstEventTimeout: 1000,
});

setTimeout(() => {
  emitter.emit("data", {});
}, 2000); // greater than firstEventTimeout ERROR!

for await (const msg of iterator) {
  console.log(msg); // never get here
}

inBetweenTimeout

import forEmitOf from 'for-emit-of';
import { EventEmitter } from "events";

const emitter = new EventEmitter();

const iterator = forEmitOf(emitter, {
  inBetweenTimeout: 1000,
});

setInterval(() => {
    emitter.emit("data", {})
}, 2000) // greater than inBetweenTimeout ERROR!
 
for await (const msg of iterator) {
  console.log(msg); // gets here once
}

Limit

import forEmitOf from 'for-emit-of';
import { EventEmitter } from "events";

const emitter = new EventEmitter();

const iterator = forEmitOf(emitter, {
    limit: 10
});

const interval = setInterval(() => {
   emitter.emit("data", {});
}, 100); 

let msgCount = 0;

for await (const msg of iterator) {
    msgCount += 1
}

clearInterval(interval);

console.log(msgCount); // 10

Debug

import forEmitOf from 'for-emit-of';
import { EventEmitter } from "events";

const emitter = new EventEmitter();

const iterator = forEmitOf(emitter, {
    limit: 10,
    debug: true // logs
});

Keep Alive

import forEmitOf from 'for-emit-of';
import { EventEmitter } from "events";

const neverEmit = new EventEmitter();

const iterator = forEmitOf(neverEmit, {
    keepAlive: 1000
});

for await (const data of iterator){
  // waiting ⌛
}