midiwire 0.1.0

package/src/core/EventEmitter.js

@@ -0,0 +1,93 @@
+/**
+ * Lightweight browser-compatible event emitter.
+ * Provides publish/subscribe functionality for MIDI events
+ * without external dependencies. Implements standard event
+ * emitter pattern: register listeners with on(), emit events
+ * with emit(), remove listeners with off(). Listener cleanup
+ * is automatic via returned unsubscribe functions.
+ */
+export class EventEmitter {
+  constructor() {
+    this.events = new Map()
+  }
+
+  /**
+   * Register an event listener
+   * @param {string} event - Event name
+   * @param {Function} handler - Event handler function
+   * @returns {Function} Unsubscribe function
+   */
+  on(event, handler) {
+    if (!this.events.has(event)) {
+      this.events.set(event, [])
+    }
+    this.events.get(event).push(handler)
+
+    // Return unsubscribe function
+    return () => this.off(event, handler)
+  }
+
+  /**
+   * Register a one-time event listener
+   * @param {string} event - Event name
+   * @param {Function} handler - Event handler function
+   */
+  once(event, handler) {
+    const onceHandler = (...args) => {
+      handler(...args)
+      this.off(event, onceHandler)
+    }
+    this.on(event, onceHandler)
+  }
+
+  /**
+   * Remove an event listener
+   * @param {string} event - Event name
+   * @param {Function} handler - Event handler function
+   */
+  off(event, handler) {
+    if (!this.events.has(event)) return
+
+    const handlers = this.events.get(event)
+    const index = handlers.indexOf(handler)
+    if (index > -1) {
+      handlers.splice(index, 1)
+    }
+
+    if (handlers.length === 0) {
+      this.events.delete(event)
+    }
+  }
+
+  /**
+   * Emit an event
+   * @param {string} event - Event name
+   * @param {*} data - Event data
+   */
+  emit(event, data) {
+    if (!this.events.has(event)) return
+
+    // Create a copy to avoid modification during iteration
+    const handlers = [...this.events.get(event)]
+
+    handlers.forEach((handler) => {
+      try {
+        handler(data)
+      } catch (err) {
+        console.error(`Error in event handler for "${event}":`, err)
+      }
+    })
+  }
+
+  /**
+   * Remove all event listeners
+   * @param {string} [event] - Optional event name to clear specific event
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.events.delete(event)
+    } else {
+      this.events.clear()
+    }
+  }
+}

package/src/core/EventEmitter.test.js

@@ -0,0 +1,357 @@
+import { describe, expect, it, vi } from "vitest"
+import { EventEmitter } from "./EventEmitter.js"
+
+describe("EventEmitter", () => {
+  describe("on and emit", () => {
+    it("should register and trigger event handlers", () => {
+      const emitter = new EventEmitter()
+      const handler = vi.fn()
+
+      emitter.on("test", handler)
+      emitter.emit("test", "data")
+
+      expect(handler).toHaveBeenCalledTimes(1)
+      expect(handler).toHaveBeenCalledWith("data")
+    })
+
+    it("should support multiple handlers for same event", () => {
+      const emitter = new EventEmitter()
+      const handler1 = vi.fn()
+      const handler2 = vi.fn()
+
+      emitter.on("test", handler1)
+      emitter.on("test", handler2)
+      emitter.emit("test", "data")
+
+      expect(handler1).toHaveBeenCalledTimes(1)
+      expect(handler2).toHaveBeenCalledTimes(1)
+    })
+
+    it("should pass single data argument to handlers", () => {
+      const emitter = new EventEmitter()
+      const handler = vi.fn()
+
+      emitter.on("test", handler)
+      emitter.emit("test", "arg1")
+
+      expect(handler).toHaveBeenCalledWith("arg1")
+    })
+
+    it("should not call handlers for different events", () => {
+      const emitter = new EventEmitter()
+      const handler = vi.fn()
+
+      emitter.on("test1", handler)
+      emitter.emit("test2", "data")
+
+      expect(handler).not.toHaveBeenCalled()
+    })
+
+    it("should handle events with no handlers", () => {
+      const emitter = new EventEmitter()
+      expect(() => emitter.emit("test", "data")).not.toThrow()
+    })
+  })
+
+  describe("once", () => {
+    it("should only call handler once", () => {
+      const emitter = new EventEmitter()
+      const handler = vi.fn()
+
+      emitter.once("test", handler)
+      emitter.emit("test", "data1")
+      emitter.emit("test", "data2")
+
+      expect(handler).toHaveBeenCalledTimes(1)
+      expect(handler).toHaveBeenCalledWith("data1")
+    })
+
+    it("should handle multiple once handlers", () => {
+      const emitter = new EventEmitter()
+      const handler1 = vi.fn()
+      const handler2 = vi.fn()
+
+      emitter.once("test", handler1)
+      emitter.once("test", handler2)
+      emitter.emit("test", "data")
+
+      // Both handlers should be called once each
+      expect(handler1).toHaveBeenCalledTimes(1)
+      expect(handler2).toHaveBeenCalledTimes(1)
+      expect(handler1).toHaveBeenCalledWith("data")
+      expect(handler2).toHaveBeenCalledWith("data")
+
+      emitter.emit("test", "data2")
+
+      // Neither should be called again
+      expect(handler1).toHaveBeenCalledTimes(1)
+      expect(handler2).toHaveBeenCalledTimes(1)
+    })
+
+    it("should allow mixing once and regular handlers", () => {
+      const emitter = new EventEmitter()
+      const onceHandler = vi.fn()
+      const regularHandler = vi.fn()
+
+      emitter.once("test", onceHandler)
+      emitter.on("test", regularHandler)
+
+      emitter.emit("test", "data1")
+      emitter.emit("test", "data2")
+
+      // onceHandler should be called once, regularHandler twice
+      expect(onceHandler).toHaveBeenCalledTimes(1)
+      expect(onceHandler).toHaveBeenCalledWith("data1")
+      expect(regularHandler).toHaveBeenCalledTimes(2)
+      expect(regularHandler).toHaveBeenNthCalledWith(1, "data1")
+      expect(regularHandler).toHaveBeenNthCalledWith(2, "data2")
+    })
+
+    it("should handle once handler removing itself during emit", () => {
+      const emitter = new EventEmitter()
+      const handler1 = vi.fn()
+      const handler2 = vi.fn()
+      const handler3 = vi.fn()
+
+      emitter.once("test", handler1)
+      emitter.once("test", handler2)
+      emitter.once("test", handler3)
+
+      emitter.emit("test", "data")
+
+      // All three handlers should be called despite self-removal
+      expect(handler1).toHaveBeenCalledTimes(1)
+      expect(handler2).toHaveBeenCalledTimes(1)
+      expect(handler3).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe("off", () => {
+    it("should remove a handler", () => {
+      const emitter = new EventEmitter()
+      const handler = vi.fn()
+
+      emitter.on("test", handler)
+      emitter.off("test", handler)
+      emitter.emit("test", "data")
+
+      expect(handler).not.toHaveBeenCalled()
+    })
+
+    it("should only remove specified handler", () => {
+      const emitter = new EventEmitter()
+      const handler1 = vi.fn()
+      const handler2 = vi.fn()
+
+      emitter.on("test", handler1)
+      emitter.on("test", handler2)
+      emitter.off("test", handler1)
+      emitter.emit("test", "data")
+
+      expect(handler1).not.toHaveBeenCalled()
+      expect(handler2).toHaveBeenCalledTimes(1)
+    })
+
+    it("should handle removing non-existent handler", () => {
+      const emitter = new EventEmitter()
+      const handler = vi.fn()
+
+      expect(() => emitter.off("test", handler)).not.toThrow()
+    })
+
+    it("should handle removing from non-existent event", () => {
+      const emitter = new EventEmitter()
+      const handler = vi.fn()
+
+      expect(() => emitter.off("nonexistent", handler)).not.toThrow()
+    })
+
+    it("should properly clean up empty event handlers", () => {
+      const emitter = new EventEmitter()
+      const handler = vi.fn()
+
+      emitter.on("test", handler)
+      emitter.off("test", handler)
+
+      // Emitting should not throw even though internal array was removed
+      expect(() => emitter.emit("test", "data")).not.toThrow()
+    })
+  })
+
+  describe("removeAllListeners", () => {
+    it("should remove all handlers from a specific event", () => {
+      const emitter = new EventEmitter()
+      const handler1 = vi.fn()
+      const handler2 = vi.fn()
+
+      emitter.on("test", handler1)
+      emitter.on("test", handler2)
+      emitter.on("other", handler1)
+
+      emitter.removeAllListeners("test")
+      emitter.emit("test", "data")
+      emitter.emit("other", "data")
+
+      expect(handler1).toHaveBeenCalledTimes(1)
+      expect(handler2).not.toHaveBeenCalled()
+    })
+
+    it("should remove all handlers from all events", () => {
+      const emitter = new EventEmitter()
+      const handler1 = vi.fn()
+      const handler2 = vi.fn()
+
+      emitter.on("test", handler1)
+      emitter.on("other", handler2)
+
+      emitter.removeAllListeners()
+      emitter.emit("test", "data")
+      emitter.emit("other", "data")
+
+      expect(handler1).not.toHaveBeenCalled()
+      expect(handler2).not.toHaveBeenCalled()
+    })
+
+    it("should handle removing from non-existent event", () => {
+      const emitter = new EventEmitter()
+      expect(() => emitter.removeAllListeners("nonexistent")).not.toThrow()
+    })
+  })
+
+  describe("on() return value", () => {
+    it("should return unsubscribe function", () => {
+      const emitter = new EventEmitter()
+      const handler = vi.fn()
+
+      const unsubscribe = emitter.on("test", handler)
+      emitter.emit("test", "data")
+      expect(handler).toHaveBeenCalledTimes(1)
+
+      unsubscribe()
+      emitter.emit("test", "data")
+      expect(handler).toHaveBeenCalledTimes(1)
+    })
+
+    it("should handle multiple unsubscribe calls", () => {
+      const emitter = new EventEmitter()
+      const handler = vi.fn()
+
+      const unsubscribe = emitter.on("test", handler)
+      unsubscribe()
+      unsubscribe() // Should not throw
+
+      emitter.emit("test", "data")
+      expect(handler).not.toHaveBeenCalled()
+    })
+  })
+
+  describe("error handling", () => {
+    it("should continue emitting when handler throws", () => {
+      const emitter = new EventEmitter()
+      const throwingHandler = vi.fn(() => {
+        throw new Error("Handler error")
+      })
+      const normalHandler = vi.fn()
+
+      const consoleError = vi.spyOn(console, "error").mockImplementation(() => {})
+
+      emitter.on("test", throwingHandler)
+      emitter.on("test", normalHandler)
+
+      expect(() => emitter.emit("test", "data")).not.toThrow()
+
+      expect(throwingHandler).toHaveBeenCalled()
+      expect(normalHandler).toHaveBeenCalledTimes(1)
+
+      consoleError.mockRestore()
+    })
+
+    it("should emit all handlers even if one throws", () => {
+      const emitter = new EventEmitter()
+      const errorHandler = vi.fn(() => {
+        throw new Error("Error")
+      })
+      const handler1 = vi.fn()
+      const handler2 = vi.fn()
+
+      vi.spyOn(console, "error").mockImplementation(() => {})
+
+      emitter.on("test", handler1)
+      emitter.on("test", errorHandler)
+      emitter.on("test", handler2)
+
+      emitter.emit("test", "data")
+
+      expect(handler1).toHaveBeenCalledTimes(1)
+      expect(handler2).toHaveBeenCalledTimes(1)
+
+      vi.restoreAllMocks()
+    })
+  })
+
+  describe("multiple events", () => {
+    it("should handle multiple different events independently", () => {
+      const emitter = new EventEmitter()
+      const handler1 = vi.fn()
+      const handler2 = vi.fn()
+      const handler3 = vi.fn()
+
+      emitter.on("event1", handler1)
+      emitter.on("event2", handler2)
+      emitter.on("event1", handler3)
+
+      emitter.emit("event1", "data1")
+      emitter.emit("event2", "data2")
+
+      expect(handler1).toHaveBeenCalledTimes(1)
+      expect(handler1).toHaveBeenCalledWith("data1")
+      expect(handler2).toHaveBeenCalledTimes(1)
+      expect(handler2).toHaveBeenCalledWith("data2")
+      expect(handler3).toHaveBeenCalledTimes(1)
+      expect(handler3).toHaveBeenCalledWith("data1")
+    })
+
+    it("should handle large number of events", () => {
+      const emitter = new EventEmitter()
+      const handlers = []
+
+      for (let i = 0; i < 100; i++) {
+        handlers.push(function handler() {})
+        emitter.on(`event${i}`, handlers[i])
+      }
+
+      expect(() => emitter.emit("event50", "test")).not.toThrow()
+    })
+  })
+
+  describe("handler order", () => {
+    it("should call handlers in order of registration", () => {
+      const emitter = new EventEmitter()
+      const calls = []
+
+      emitter.on("test", () => calls.push(1))
+      emitter.on("test", () => calls.push(2))
+      emitter.on("test", () => calls.push(3))
+
+      emitter.emit("test")
+
+      expect(calls).toEqual([1, 2, 3])
+    })
+
+    it("should maintain order when removing middle handler", () => {
+      const emitter = new EventEmitter()
+      const calls = []
+
+      const handler2 = () => calls.push(2)
+
+      emitter.on("test", () => calls.push(1))
+      emitter.on("test", handler2)
+      emitter.on("test", () => calls.push(3))
+
+      emitter.off("test", handler2)
+      emitter.emit("test")
+
+      expect(calls).toEqual([1, 3])
+    })
+  })
+})