@lowentry/utils 1.21.1 → 1.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowentry/utils",
-  "version": "1.21.1",
+  "version": "1.22.1",
   "private": false,
   "type": "module",
   "main": "./index.js",

package/src/classes/EventEmitter.js

@@ -0,0 +1,124 @@
+/**
+ * A simple event emitter class that allows you to register listeners for events, emit events, and remove listeners.
+ */
+export class EventEmitter
+{
+	/** @type {Map<string, Set<Function>>} */
+	#events;
+	
+	
+	/**
+	 * Creates a new EventEmitter instance.
+	 */
+	constructor()
+	{
+		this.#events = new Map();
+	}
+	
+	
+	/**
+	 * Registers a listener for a specific event.
+	 *
+	 * @param {string} event - The name of the event to listen for.
+	 * @param {Function} listener - The function to call when the event is emitted.
+	 * @returns {{remove:(()=>void)}}
+	 */
+	on(event, listener)
+	{
+		if(!this.#events.has(event))
+		{
+			this.#events.set(event, new Set());
+		}
+		this.#events.get(event)?.add(listener);
+		
+		return {
+			remove:
+				() => this.off(event, listener),
+		};
+	}
+	
+	/**
+	 * Registers a listener for a specific event, this listener will be called only once.
+	 *
+	 * @param {string} event - The name of the event to listen for.
+	 * @param {Function} listener - The function to call when the event is emitted.
+	 * @returns {{remove:()=>void}}
+	 */
+	once(event, listener)
+	{
+		const wrapper = (/** @type {*[]} */ ...args) =>
+		{
+			this.off(event, wrapper);
+			listener(...args);
+		};
+		
+		this.on(event, wrapper);
+		
+		return {
+			remove:
+				() => this.off(event, wrapper),
+		};
+	}
+	
+	/**
+	 * Removes a listener for a specific event.
+	 *
+	 * @param {string} event - The name of the event to stop listening for.
+	 * @param {Function} listener - The function to remove from the event listeners.
+	 */
+	off(event, listener)
+	{
+		const listeners = this.#events.get(event);
+		if(listeners)
+		{
+			listeners.delete(listener);
+			if(listeners.size === 0)
+			{
+				this.#events.delete(event);
+			}
+		}
+	}
+	
+	/**
+	 * Emits an event, calling all registered listeners with the provided arguments.
+	 *
+	 * @param {string} event - The name of the event to emit.
+	 * @param {...*} args - The arguments to pass to the listeners.
+	 */
+	emit(event, ...args)
+	{
+		const listeners = this.#events.get(event);
+		if(listeners)
+		{
+			const snapshot = [...listeners];
+			for(const listener of snapshot)
+			{
+				try
+				{
+					listener(...args);
+				}
+				catch(err)
+				{
+					console.error(`Error in listener for "${event}":`, err);
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Clears all listeners for a specific event or all events if no event is specified.
+	 *
+	 * @param {string} [event] - The name of the event to clear listeners for. If not provided, all events will be cleared.
+	 */
+	clear(event)
+	{
+		if(event !== undefined)
+		{
+			this.#events.delete(event);
+		}
+		else
+		{
+			this.#events.clear();
+		}
+	}
+}

package/src/index.js

@@ -1,5 +1,6 @@
 export {LeUtils} from './LeUtils.js';
 export {ISSET, IS_ARRAY, ARRAY, IS_OBJECT, OBJECT, STRING, STRING_ANY, INT, INT_ANY, FLOAT, FLOAT_ANY, INT_LAX, INT_LAX_ANY, FLOAT_LAX, FLOAT_LAX_ANY} from './LeTypes.js';
+export {EventEmitter} from './classes/EventEmitter.js';
 export {LinkedList} from './classes/LinkedList.js';
 export {SerializableMap} from './classes/SerializableMap.js';
 export {TreeSet} from './classes/TreeSet.js';

package/tests/event-emitter.test.js

@@ -0,0 +1,179 @@
+import {describe, test, expect} from 'vitest';
+import {EventEmitter} from '../src/index.js';
+
+
+describe('EventEmitter', () =>
+{
+	test('should create an instance of EventEmitter', () =>
+	{
+		const emitter = new EventEmitter();
+		expect(emitter).toBeInstanceOf(EventEmitter);
+	});
+	
+	test('should emit and listen to events', () =>
+	{
+		const emitter = new EventEmitter();
+		let called = 0;
+		
+		emitter.on('testEvent', () =>
+		{
+			called++;
+		});
+		
+		emitter.emit('testEvent');
+		expect(called).toBe(1);
+	});
+	
+	test('should remove event listeners', () =>
+	{
+		const emitter = new EventEmitter();
+		let called = 0;
+		
+		const listener = () =>
+		{
+			called++;
+		};
+		
+		emitter.on('testEvent', listener);
+		emitter.off('testEvent', listener);
+		
+		emitter.emit('testEvent');
+		expect(called).toBe(0);
+	});
+	
+	test('should handle multiple listeners for the same event', () =>
+	{
+		const emitter = new EventEmitter();
+		let called1 = 0;
+		let called2 = 0;
+		
+		const listener1 = () =>
+		{
+			called1++;
+		};
+		const listener2 = () =>
+		{
+			called2++;
+		};
+		
+		emitter.on('testEvent', listener1);
+		emitter.on('testEvent', listener2);
+		
+		emitter.emit('testEvent');
+		expect(called1).toBe(1);
+		expect(called2).toBe(1);
+		
+		emitter.off('testEvent', listener1);
+		emitter.emit('testEvent');
+		expect(called1).toBe(1);
+		expect(called2).toBe(2);
+	});
+	
+	test('should handle event names with special characters', () =>
+	{
+		const emitter = new EventEmitter();
+		let called = 0;
+		
+		emitter.on('test-event!@#$', () =>
+		{
+			called++;
+		});
+		
+		emitter.emit('test-event!@#$');
+		expect(called).toBe(1);
+	});
+	
+	test('should handle event names with spaces', () =>
+	{
+		const emitter = new EventEmitter();
+		let called = 0;
+		
+		emitter.on('test event with spaces', () =>
+		{
+			called++;
+		});
+		
+		emitter.emit('test event with spaces');
+		expect(called).toBe(1);
+	});
+	
+	test('should be able to remove a listener using the returned listener object', () =>
+	{
+		const emitter = new EventEmitter();
+		let called = 0;
+		
+		const listener = emitter.on('test123', () =>
+		{
+			called++;
+		});
+		
+		emitter.emit('test123');
+		expect(called).toBe(1);
+		
+		listener.remove();
+		emitter.emit('test123');
+		expect(called).toBe(1);
+	});
+	
+	test('should handle multiple events with the same name', () =>
+	{
+		const emitter = new EventEmitter();
+		let called1 = 0;
+		let called2 = 0;
+		
+		emitter.on('testEvent', () =>
+		{
+			called1++;
+		});
+		
+		emitter.on('testEvent', () =>
+		{
+			called2++;
+		});
+		
+		emitter.emit('testEvent');
+		expect(called1).toBe(1);
+		expect(called2).toBe(1);
+		
+		emitter.clear('testEvent');
+		emitter.emit('testEvent');
+		expect(called1).toBe(1);
+		expect(called2).toBe(1);
+	});
+	
+	test('should handle once() method', () =>
+	{
+		const emitter = new EventEmitter();
+		let called = 0;
+		
+		emitter.once('testOnce', () =>
+		{
+			called++;
+		});
+		
+		emitter.emit('testOnce');
+		expect(called).toBe(1);
+		
+		emitter.emit('testOnce');
+		expect(called).toBe(1);
+	});
+	
+	test('should allow canceling a once listener using .remove()', () =>
+	{
+		const emitter = new EventEmitter();
+		let called = 0;
+		
+		const listener = emitter.once('testOnceCancel', () =>
+		{
+			called++;
+		});
+		
+		listener.remove();
+		
+		emitter.emit('testOnceCancel');
+		expect(called).toBe(0);
+		
+		emitter.emit('testOnceCancel');
+		expect(called).toBe(0);
+	});
+});