@anephenix/event-emitter 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Anephenix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+event-emitter
+
+A small event emitter library, designed for use in front-end applications
+like Svelte applications.
+
+This provides a nice way to connect different parts of an application whilst
+keeping the underlying components decoupled from each other.
+
+## Installation
+
+```shell
+npm i @anephenix/event-emitter
+```
+
+## Usage
+
+```typescript
+// Load the dependency class
+import EventEmitter from "@anephenix/event-emitter";
+
+// Create an instance of the event emitter class with type safety
+const eventEmitter = new EventEmitter();
+```
+
+We can now pass that eventEmitter instance to the places where we want to
+either trigger an event or react to an event.
+
+Whether you do that by loading the eventEmitter instance as a dependency
+within a file, or by passing it as a parameter to a function is completely
+up to you. The important thing is that you use the same eventEmitter
+instance for handling the events that you want to trigger and react to.
+
+### Triggering an event
+
+To trigger an event, you call the `.emit` function on the eventEmitter
+instance with the name of the event, and the data that you wish to pass along
+with that event.
+
+```typescript
+const data = { name: "John", text: "Hello" };
+eventEmitter.emit("message", data);
+```
+
+### Handling an event
+
+To handle an event, you call the `.on` function on the eventEmitter instance
+with the name of the event, and a listener function that handles the data payload
+received when the event is triggered.
+
+```typescript
+const messages = [];
+
+function handleMessage(data: { name: string; text: string }) {
+    messages.push(data);
+}
+
+eventEmitter.on("message", handleMessage);
+```
+
+You can trigger and handle as many events as you like, and even add multiple
+handler functions for the same event.
+
+### Removing event handlers
+
+To clean up event handlers that are no longer required (e.g. for a component
+that is no longer in view), you can call the `.off` function with a reference
+to the function that was passed to the `.on` function:
+
+```typescript
+eventEmitter.off("message", handleMessage);
+```
+
+### Applying Type Safety to events names and their payloads
+
+You may find that you'll want to add some type safety to the list of event 
+names that are used in your application, as well as the data payloads that
+they emit and pass to handler functions.
+
+The library allows you to define that by using a Type that is passed to the
+setup of the EventEmitter instance, like this:
+
+```typescript
+interface MyEvents {
+  message: (data: string) => void;
+  join: (username: string) => void;
+  leave: (username: string) => void;
+}
+
+const emitter = new EventEmitter<MyEvents>();
+```
+
+This will then provide a way to ensure that calls to emit events and react to 
+them are type-checked:
+
+```typescript
+emitter.on('join', (username:string) => {
+    console.log(`${username} joined`);
+});
+
+emitter.emit("join", "Alice");
+```
+
+This will help with preventing the misspelling of event names and also ensuring 
+that the event data payloads are correct.
+
+## Tests
+
+You can run the unit tests using this command:
+
+```shell
+npm t
+```
+
+## Licence and Credits
+
+&copy;2025 Anephenix OÜ. EventEmitter is licenced under the MIT licence.

package/package.json

@@ -0,0 +1,59 @@
+{
+	"name": "@anephenix/event-emitter",
+	"version": "0.0.3",
+	"description": "A small EventEmitter library",
+	"author": "Paul Jensen <paul@anephenix.com>",
+	"maintainers": [
+		{
+			"name": "Paul Jensen",
+			"email": "paul@anephenix.com"
+		}
+	],
+	"keywords": [
+		"event-emitter"
+	],
+	"homepage": "https://github.com/anephenix/event-emitter#readme",
+	"bugs": {
+		"url": "https://github.com/anephenix/event-emitter/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/anephenix/event-emitter.git"
+	},
+	"license": "MIT",
+	"type": "module",
+	"main": "dist/index.js",
+	"typings": "dist/index.d.ts",
+	"files": [
+		"dist",
+		"src"
+	],
+	"scripts": {
+		"build": "tsc --project tsconfig.json",
+		"cover": "npx nyc --reporter=lcov --reporter=text-summary --nycrc-path=./.nyc.json -- npm t --  --coverage",
+		"lint": "biome lint",
+		"format": "biome format --fix",
+		"prepare": "husky install",
+		"prepare-patch-release": "npm run update-changelog && git add CHANGELOG.md && git commit -m \"Updated changelog\" && npm version patch",
+		"publish-patch-release": "npm run prepare-patch-release && git push origin main && git push --tags",
+		"size": "size-limit",
+		"test": "vitest --run",
+		"update-changelog": "node --experimental-strip-types scripts/update-changelog.ts"
+	},
+	"size-limit": [
+		{
+			"path": "dist/*.js",
+			"limit": "10 KB"
+		}
+	],
+	"devDependencies": {
+		"@biomejs/biome": "^1.9.4",
+		"@size-limit/esbuild-why": "^11.2.0",
+		"@size-limit/preset-small-lib": "^11.2.0",
+		"@vitest/coverage-v8": "^3.1.3",
+		"husky": "^9.1.7",
+		"size-limit": "^11.2.0",
+		"typescript": "^5.8.3",
+		"vitest": "^3.1.3"
+	}
+}

package/src/EventEmitter.ts

@@ -0,0 +1,37 @@
+// Generic type for an event map where each key has a listener signature
+type EventMap = Record<string, (...args: any[]) => void>;
+
+class EventEmitter<T extends EventMap> {
+	private events: { [K in keyof T]?: T[K][] } = {};
+	enableLogging = false;
+
+	log(...args: unknown[]) {
+		if (this.enableLogging) {
+			console.log(...args);
+		}
+	}
+
+	on<K extends keyof T>(event: K, listener: T[K]): void {
+		if (!this.events[event]) {
+			this.events[event] = [];
+		}
+		this.events[event]!.push(listener);
+	}
+
+	off<K extends keyof T>(event: K, listener: T[K]): void {
+		const listeners = this.events[event];
+		if (!listeners) return;
+		this.events[event] = listeners.filter((l) => l !== listener);
+	}
+
+	emit<K extends keyof T>(event: K, ...args: Parameters<T[K]>): void {
+		this.log("Emitting event:", event, "with args:", ...args);
+		const listeners = this.events[event];
+		if (!listeners) return;
+		for (const listener of listeners) {
+			listener(...args);
+		}
+	}
+}
+
+export default EventEmitter;

package/src/index.ts

@@ -0,0 +1,2 @@
+import EventEmitter from "./EventEmitter";
+export default EventEmitter;