How to Create a Custom Priority Event Emitter in Node.js

npm i -d @types/node tsx typescript
npx tsc --init

// tsconfig.json
{
  "compilerOptions": {
    "target": "es2016",
    "module": "ES6",
    "moduleResolution": "nodenext",
    "allowImportingTsExtensions": true,
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "skipLibCheck": true,
    "sourceMap": true,
    "outDir": "./dist",
    "types": ["node"]
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules"]
}

// package.json
{
  "name": "node-starter",
  "version": "0.0.0",
  "type": "module", // This should be set to "module" for using ES6 modules
  "scripts": {
    "test": "jest"
  },
  "devDependencies": {
    "@types/jest": "^29.5.14",
    "jest": "^29.7.0",
    "typescript": "^5.7.2"
  },
  "dependencies": {
    "@types/node": "^22.10.2",
    "tsx": "^4.19.2"
  }
}

- `PriorityEmitter` extends `EventEmitter`, so it inherits all of its functionality.
- We introduce a new internal property `_listeners` to store listeners along with their priorities.

- For production usage, consider using other data structures instead of arrays, which maintain order.
- When a listener is added using `on`, we push the listener and its priority into the `_listeners` array.
- We then sort the listeners in descending order based on the priority. This ensures that higher-priority listeners are executed first.
- The default priority is `0` if not specified.

- For the given event, we iterate over the sorted listeners and call each listener.
- After handling the custom priority-based logic, we call the parent class’s `emit` method to ensure the standard behavior is also preserved.

- We filter the listener array to remove the listener with the exact reference.
- Then we call `super.removeListener` to ensure proper cleanup and avoid memory leaks.

const pe = new PriorityEmitter();

// Listener with higher priority
pe.on('greet', (name: string) => {
  console.log(`Hello ${name}!`);
}, 2);

// Listener with lower priority
pe.on('greet', (name: string) => {
  console.log(`Hi, ${name}!`);
}, 1);

// Emitting the event
pe.emit('greet', 'Alice');

-- Run using this command
❯ npx tsx PriorityEvent.ts
Hello Alice!
Hi, Alice!

// This a basic example of priority Event emitter, for production use heaps instead of sorting in 
// each insertion we can use maxHeap to always choose the max priority first.
import EventEmitter from 'events';

export class PriorityEmitter extends EventEmitter {
  // This field will store a map of all the events string with assigned listeners to them.
  // Without custom logic, nodejs invokes the listeners in the order in which they were registered.
  // So we add custom logic by overriding the on and emit methods of the EventEmitter class.  
  private _listeners: Record<
    string,
    { listener: (...args: any[]) => void; priority: number }[]
  >;

  constructor() {
    super();
    this._listeners = {};
  }

  // Override the on method with our custom logic for ordering.  
  on(event: string, listener: (...args: any[]) => void, priority = 0) {
    if (!this._listeners[event]) this._listeners[event] = [];
    this._listeners[event].push({ listener, priority });
    this._listeners[event].sort((a, b) => b.priority - a.priority);
    return this;
  }

  // Override the emit method  
  emit(event: string, ...args: any[]) {
    if (this._listeners[event]) {
      for (const { listener } of this._listeners[event]) {
        listener(...args);
      }
    }
    return super.emit(event, ...args);
  }

  // Override the remove listener method    
  removeListener(event: string, listener: (...args: any[]) => void) {
    if (this._listeners[event]) {
      this._listeners[event] = this._listeners[event].filter(
        (stored_listener) => stored_listener.listener !== listener
      );
    }
    super.removeListener(event, listener);
    return this;
  }
}

const pe = new PriorityEmitter();

// This will be invoked first as this has higher priority.
pe.on(
  'greet',
  (name: string) => {
    console.log(`Hello ${name}!`);
  },
  2
);

// This will be invoked later on as this has lower priority.
pe.on(
  'greet',
  (name: string) => {
    console.log(`Hi, ${name}!`);
  },
  1
);

// Here we emit the event by passing the name as parameter, it will invoke all the listeners by
// priority.
pe.emit('greet', 'Alice');