@blibliki/engine 0.3.9 → 0.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blibliki/engine",
-  "version": "0.3.9",
+  "version": "0.3.10",
   "type": "module",
   "source": "src/index.ts",
   "main": "dist/index.cjs",
@@ -17,11 +17,11 @@
     "vitest": "^4.0.6"
   },
   "dependencies": {
+    "@julusian/midi": "^3.6.1",
     "es-toolkit": "^1.41.0",
-    "jzz": "^1.9.6",
     "node-web-audio-api": "^1.0.3",
-    "@blibliki/utils": "^0.3.9",
-    "@blibliki/transport": "^0.3.9"
+    "@blibliki/utils": "^0.3.10",
+    "@blibliki/transport": "^0.3.10"
   },
   "scripts": {
     "build": "tsup",

package/src/core/midi/MidiDevice.ts

@@ -1,7 +1,7 @@
 import { Context } from "@blibliki/utils";
-import type { JZZMidiMessage, JZZPort } from "./jzz.types";
-import MidiEvent, { MidiEventType } from "./MidiEvent";
 import Message from "./Message";
+import MidiEvent, { MidiEventType } from "./MidiEvent";
+import type { IMidiInputPort, IMidiMessageEvent } from "./adapters";
 
 export enum MidiPortState {
   connected = "connected",
@@ -26,12 +26,12 @@ export default class MidiDevice implements IMidiDevice {
   eventListerCallbacks: EventListerCallback[] = [];
 
   private context: Readonly<Context>;
-  private input: JZZPort;
-  private _state: MidiPortState = MidiPortState.connected;
+  private input: IMidiInputPort;
+  private messageHandler: ((event: IMidiMessageEvent) => void) | null = null;
 
-  constructor(input: JZZPort, id: string, name: string, context: Context) {
-    this.id = id;
-    this.name = name || `Device ${id}`;
+  constructor(input: IMidiInputPort, context: Context) {
+    this.id = input.id;
+    this.name = input.name;
     this.input = input;
     this.context = context;
 
@@ -39,19 +39,21 @@ export default class MidiDevice implements IMidiDevice {
   }
 
   get state() {
-    return this._state;
+    return this.input.state as MidiPortState;
   }
 
   connect() {
-    // JZZ uses a callback function to receive MIDI messages
-    this.input.connect((msg: JZZMidiMessage) => {
-      this.processEvent(msg);
-    });
+    this.messageHandler = (e: IMidiMessageEvent) => {
+      this.processEvent(e);
+    };
+    this.input.addEventListener(this.messageHandler);
   }
 
   disconnect() {
-    this.input.close();
-    this._state = MidiPortState.disconnected;
+    if (this.messageHandler) {
+      this.input.removeEventListener(this.messageHandler);
+      this.messageHandler = null;
+    }
   }
 
   serialize() {
@@ -70,16 +72,11 @@ export default class MidiDevice implements IMidiDevice {
     );
   }
 
-  private processEvent(msg: JZZMidiMessage) {
-    // Convert JZZ MIDI message to Uint8Array
-    const data = new Uint8Array(msg.slice());
-    const message = new Message(data);
-
-    // Use current time as timestamp since JZZ doesn't provide precise timestamps
-    const timestamp = performance.now();
+  private processEvent(event: IMidiMessageEvent) {
+    const message = new Message(event.data);
     const midiEvent = new MidiEvent(
       message,
-      this.context.browserToContextTime(timestamp),
+      this.context.browserToContextTime(event.timeStamp),
     );
 
     switch (midiEvent.type) {

package/src/core/midi/MidiDeviceManager.ts

@@ -1,8 +1,7 @@
 import { Context } from "@blibliki/utils";
-import JZZ from "jzz";
-import type { JZZ as JZZType, JZZInputInfo, JZZPort } from "./jzz.types";
 import ComputerKeyboardDevice from "./ComputerKeyboardDevice";
 import MidiDevice from "./MidiDevice";
+import { createMidiAdapter, type IMidiAccess } from "./adapters";
 
 type ListenerCallback = (device: MidiDevice) => void;
 
@@ -11,7 +10,8 @@ export default class MidiDeviceManager {
   private initialized = false;
   private listeners: ListenerCallback[] = [];
   private context: Readonly<Context>;
-  private jzz: JZZType | null = null;
+  private midiAccess: IMidiAccess | null = null;
+  private adapter = createMidiAdapter();
 
   constructor(context: Context) {
     this.context = context;
@@ -41,21 +41,25 @@ export default class MidiDeviceManager {
     if (this.initialized) return;
 
     try {
-      const jzz: JZZType = (await JZZ()) as unknown as JZZType;
-      this.jzz = jzz;
-      const info = jzz.info();
-
-      // Get all MIDI input devices
-      for (const inputInfo of info.inputs ?? []) {
-        const id: string = inputInfo.id ?? inputInfo.name;
-        if (!this.devices.has(id)) {
-          const port = (await jzz.openMidiIn(inputInfo.name)) as unknown as JZZPort;
-          const device = new MidiDevice(port, id, inputInfo.name, this.context);
-          this.devices.set(id, device);
+      if (!this.adapter.isSupported()) {
+        console.warn("MIDI is not supported on this platform");
+        return;
+      }
+
+      this.midiAccess = await this.adapter.requestMIDIAccess();
+
+      if (!this.midiAccess) {
+        console.error("Failed to get MIDI access");
+        return;
+      }
+
+      for (const input of this.midiAccess.inputs()) {
+        if (!this.devices.has(input.id)) {
+          this.devices.set(input.id, new MidiDevice(input, this.context));
         }
       }
     } catch (err) {
-      console.error("Error enabling JZZ MIDI:", err);
+      console.error("Error enabling MIDI:", err);
     }
   }
 
@@ -67,53 +71,31 @@ export default class MidiDeviceManager {
   }
 
   private listenChanges() {
-    if (!this.jzz) return;
-
-    // JZZ watch for MIDI device changes
-    this.jzz.onChange(() => {
-      if (!this.jzz) return;
-
-      const info = this.jzz.info();
-      const currentInputIds = new Set<string>(
-        (info.inputs ?? []).map((i: JZZInputInfo) => i.id ?? i.name),
-      );
-
-      // Check for new devices
-      for (const inputInfo of info.inputs ?? []) {
-        const id: string = inputInfo.id ?? inputInfo.name;
-        if (!this.devices.has(id)) {
-          // New device connected
-          void this.jzz
-            .openMidiIn(inputInfo.name)
-            .then((port: unknown) => {
-              const jzzPort = port as JZZPort;
-              const device = new MidiDevice(
-                jzzPort,
-                id,
-                inputInfo.name,
-                this.context,
-              );
-              this.devices.set(id, device);
-
-              this.listeners.forEach((listener) => {
-                listener(device);
-              });
-            });
-        }
-      }
-
-      // Check for removed devices
-      for (const [id, device] of this.devices) {
-        if (device instanceof ComputerKeyboardDevice) continue;
-        if (!currentInputIds.has(id)) {
-          // Device disconnected
-          device.disconnect();
-          this.devices.delete(id);
-
-          this.listeners.forEach((listener) => {
-            listener(device);
-          });
-        }
+    if (!this.midiAccess) return;
+
+    this.midiAccess.addEventListener("statechange", (port) => {
+      if (port.state === "connected") {
+        // Device connected
+        if (this.devices.has(port.id)) return;
+
+        const device = new MidiDevice(port, this.context);
+        this.devices.set(device.id, device);
+
+        this.listeners.forEach((listener) => {
+          listener(device);
+        });
+      } else {
+        // Device disconnected
+        const device = this.devices.get(port.id);
+        if (!device) return;
+        if (device instanceof ComputerKeyboardDevice) return;
+
+        device.disconnect();
+        this.devices.delete(device.id);
+
+        this.listeners.forEach((listener) => {
+          listener(device);
+        });
       }
     });
   }

package/src/core/midi/MidiEvent.ts

@@ -1,6 +1,6 @@
 import { ContextTime } from "@blibliki/transport";
-import Message from "./Message";
 import Note, { INote } from "../Note";
+import Message from "./Message";
 
 export enum MidiEventType {
   noteOn = "noteon",

package/src/core/midi/adapters/NodeMidiAdapter.ts

@@ -0,0 +1,174 @@
+/**
+ * node-midi adapter for Node.js
+ */
+import { isNode } from "es-toolkit";
+import type {
+  IMidiAccess,
+  IMidiAdapter,
+  IMidiInputPort,
+  MidiMessageCallback,
+} from "./types";
+
+// Dynamic import type for node-midi
+type NodeMidiInput = {
+  getPortCount(): number;
+  getPortName(port: number): string;
+  openPort(port: number): void;
+  closePort(): void;
+  on(
+    event: "message",
+    callback: (deltaTime: number, message: number[]) => void,
+  ): void;
+  off(
+    event: "message",
+    callback: (deltaTime: number, message: number[]) => void,
+  ): void;
+  isPortOpen(): boolean;
+};
+
+type NodeMidiModule = {
+  Input: new () => NodeMidiInput;
+};
+
+class NodeMidiInputPort implements IMidiInputPort {
+  readonly id: string;
+  readonly name: string;
+  private portIndex: number;
+  private input: NodeMidiInput;
+  private callbacks = new Set<MidiMessageCallback>();
+  private handler: ((deltaTime: number, message: number[]) => void) | null =
+    null;
+  private _state: "connected" | "disconnected" = "disconnected";
+
+  constructor(portIndex: number, name: string, input: NodeMidiInput) {
+    this.portIndex = portIndex;
+    this.id = `node-midi-${portIndex}`;
+    this.name = name;
+    this.input = input;
+  }
+
+  get state(): "connected" | "disconnected" {
+    return this._state;
+  }
+
+  setState(state: "connected" | "disconnected"): void {
+    this._state = state;
+  }
+
+  addEventListener(callback: MidiMessageCallback): void {
+    if (this.callbacks.size === 0) {
+      this.handler = (_deltaTime: number, message: number[]) => {
+        const event = {
+          data: new Uint8Array(message),
+          timeStamp: performance.now(),
+        };
+
+        this.callbacks.forEach((cb) => {
+          cb(event);
+        });
+      };
+
+      try {
+        if (!this.input.isPortOpen()) {
+          this.input.openPort(this.portIndex);
+          this._state = "connected";
+        }
+        this.input.on("message", this.handler);
+      } catch (err) {
+        console.error(`Error opening MIDI port ${this.portIndex}:`, err);
+      }
+    }
+    this.callbacks.add(callback);
+  }
+
+  removeEventListener(callback: MidiMessageCallback): void {
+    this.callbacks.delete(callback);
+
+    if (this.callbacks.size === 0 && this.handler) {
+      try {
+        this.input.off("message", this.handler);
+        if (this.input.isPortOpen()) {
+          this.input.closePort();
+          this._state = "disconnected";
+        }
+      } catch (err) {
+        console.error(`Error closing MIDI port ${this.portIndex}:`, err);
+      }
+      this.handler = null;
+    }
+  }
+}
+
+class NodeMidiAccess implements IMidiAccess {
+  private ports = new Map<string, NodeMidiInputPort>();
+  private MidiModule: NodeMidiModule;
+
+  constructor(MidiModule: NodeMidiModule) {
+    this.MidiModule = MidiModule;
+    this.scanPorts();
+  }
+
+  private scanPorts(): void {
+    try {
+      const input = new this.MidiModule.Input();
+      const portCount = input.getPortCount();
+
+      for (let i = 0; i < portCount; i++) {
+        const portName = input.getPortName(i);
+        const id = `node-midi-${i}`;
+
+        if (!this.ports.has(id)) {
+          // Create a new input instance for each port
+          const portInput = new this.MidiModule.Input();
+          const port = new NodeMidiInputPort(i, portName, portInput);
+          this.ports.set(id, port);
+        }
+      }
+
+      // Clean up the scanning input
+      if (input.isPortOpen()) {
+        input.closePort();
+      }
+    } catch (err) {
+      console.error("Error scanning MIDI ports:", err);
+    }
+  }
+
+  *inputs(): IterableIterator<IMidiInputPort> {
+    for (const [, port] of this.ports) {
+      yield port;
+    }
+  }
+
+  addEventListener(
+    _event: "statechange",
+    _callback: (port: IMidiInputPort) => void,
+  ): void {
+    // node-midi doesn't support hot-plugging detection
+    // This could be implemented with polling if needed
+    console.warn(
+      "Hot-plug detection not supported with node-midi adapter. Restart required for new devices.",
+    );
+  }
+}
+
+export default class NodeMidiAdapter implements IMidiAdapter {
+  async requestMIDIAccess(): Promise<IMidiAccess | null> {
+    try {
+      // Dynamic import to avoid bundling in browser builds
+      const midi = (await import("@julusian/midi")) as
+        | NodeMidiModule
+        | { default: NodeMidiModule };
+      const midiModule = "default" in midi ? midi.default : midi;
+      return new NodeMidiAccess(midiModule);
+    } catch (err) {
+      console.error("Error loading node-midi:", err);
+      return null;
+    }
+  }
+
+  isSupported(): boolean {
+    // Check if we're in Node.js environment
+    return isNode();
+  }
+}

package/src/core/midi/adapters/WebMidiAdapter.ts

@@ -0,0 +1,120 @@
+/**
+ * Web MIDI API adapter for browsers
+ */
+import type {
+  IMidiAccess,
+  IMidiAdapter,
+  IMidiInputPort,
+  MidiMessageCallback,
+} from "./types";
+
+class WebMidiInputPort implements IMidiInputPort {
+  private input: MIDIInput;
+  private callbacks = new Set<MidiMessageCallback>();
+  private handler: ((e: MIDIMessageEvent) => void) | null = null;
+
+  constructor(input: MIDIInput) {
+    this.input = input;
+  }
+
+  get id(): string {
+    return this.input.id;
+  }
+
+  get name(): string {
+    return this.input.name ?? `Device ${this.input.id}`;
+  }
+
+  get state(): "connected" | "disconnected" {
+    return this.input.state as "connected" | "disconnected";
+  }
+
+  addEventListener(callback: MidiMessageCallback): void {
+    if (this.callbacks.size === 0) {
+      this.handler = (e: MIDIMessageEvent) => {
+        if (!e.data) return;
+
+        const event = {
+          data: e.data,
+          timeStamp: e.timeStamp,
+        };
+
+        this.callbacks.forEach((cb) => {
+          cb(event);
+        });
+      };
+      this.input.addEventListener("midimessage", this.handler);
+    }
+    this.callbacks.add(callback);
+  }
+
+  removeEventListener(callback: MidiMessageCallback): void {
+    this.callbacks.delete(callback);
+
+    if (this.callbacks.size === 0 && this.handler) {
+      this.input.removeEventListener("midimessage", this.handler);
+      this.handler = null;
+    }
+  }
+}
+
+class WebMidiAccess implements IMidiAccess {
+  private midiAccess: MIDIAccess;
+  private portCache = new Map<string, WebMidiInputPort>();
+
+  constructor(midiAccess: MIDIAccess) {
+    this.midiAccess = midiAccess;
+  }
+
+  *inputs(): IterableIterator<IMidiInputPort> {
+    for (const [, input] of this.midiAccess.inputs) {
+      if (!this.portCache.has(input.id)) {
+        this.portCache.set(input.id, new WebMidiInputPort(input));
+      }
+      yield this.portCache.get(input.id)!;
+    }
+  }
+
+  addEventListener(
+    event: "statechange",
+    callback: (port: IMidiInputPort) => void,
+  ): void {
+    this.midiAccess.addEventListener(event, (e) => {
+      const port = e.port;
+      if (!port || port.type !== "input") return;
+
+      const input = port as MIDIInput;
+      if (!this.portCache.has(input.id)) {
+        this.portCache.set(input.id, new WebMidiInputPort(input));
+      }
+
+      callback(this.portCache.get(input.id)!);
+    });
+  }
+}
+
+export default class WebMidiAdapter implements IMidiAdapter {
+  async requestMIDIAccess(): Promise<IMidiAccess | null> {
+    try {
+      if (
+        typeof navigator === "undefined" ||
+        typeof navigator.requestMIDIAccess !== "function"
+      ) {
+        return null;
+      }
+
+      const midiAccess = await navigator.requestMIDIAccess();
+      return new WebMidiAccess(midiAccess);
+    } catch (err) {
+      console.error("Error enabling Web MIDI API:", err);
+      return null;
+    }
+  }
+
+  isSupported(): boolean {
+    return (
+      typeof navigator !== "undefined" &&
+      typeof navigator.requestMIDIAccess === "function"
+    );
+  }
+}

package/src/core/midi/adapters/index.ts

@@ -0,0 +1,23 @@
+/**
+ * MIDI adapter factory
+ * Automatically selects the correct MIDI implementation based on the platform
+ */
+import { isNode } from "es-toolkit";
+import NodeMidiAdapter from "./NodeMidiAdapter";
+import WebMidiAdapter from "./WebMidiAdapter";
+import type { IMidiAdapter } from "./types";
+
+export * from "./types";
+
+/**
+ * Creates the appropriate MIDI adapter for the current platform
+ * @returns The MIDI adapter (Web MIDI API for browsers, node-midi for Node.js)
+ */
+export function createMidiAdapter(): IMidiAdapter {
+  if (isNode()) {
+    return new NodeMidiAdapter();
+  }
+
+  // Default to Web MIDI API for browsers
+  return new WebMidiAdapter();
+}

package/src/core/midi/adapters/types.ts

@@ -0,0 +1,32 @@
+/**
+ * Platform-agnostic MIDI interfaces
+ * Allows switching between Web MIDI API and node-midi without refactoring
+ */
+
+export interface IMidiMessageEvent {
+  data: Uint8Array;
+  timeStamp: number;
+}
+
+export type MidiMessageCallback = (event: IMidiMessageEvent) => void;
+
+export interface IMidiInputPort {
+  readonly id: string;
+  readonly name: string;
+  readonly state: "connected" | "disconnected";
+  addEventListener(callback: MidiMessageCallback): void;
+  removeEventListener(callback: MidiMessageCallback): void;
+}
+
+export interface IMidiAccess {
+  inputs(): IterableIterator<IMidiInputPort>;
+  addEventListener(
+    event: "statechange",
+    callback: (port: IMidiInputPort) => void,
+  ): void;
+}
+
+export interface IMidiAdapter {
+  requestMIDIAccess(): Promise<IMidiAccess | null>;
+  isSupported(): boolean;
+}

package/src/core/midi/jzz.types.ts

@@ -1,51 +0,0 @@
-/**
- * Type definitions for JZZ MIDI library
- */
-
-export interface JZZInputInfo {
-  id?: string;
-  name: string;
-  manufacturer?: string;
-  version?: string;
-  engine?: string;
-}
-
-export interface JZZOutputInfo {
-  id?: string;
-  name: string;
-  manufacturer?: string;
-  version?: string;
-  engine?: string;
-}
-
-export interface JZZInfo {
-  inputs?: JZZInputInfo[];
-  outputs?: JZZOutputInfo[];
-  version?: string;
-  engine?: string;
-}
-
-export interface JZZMidiMessage extends Array<number> {
-  slice(): number[];
-}
-
-export interface JZZPort {
-  connect(callback: (msg: JZZMidiMessage) => void): JZZPort;
-  close(): void;
-  disconnect(): void;
-}
-
-// JZZ uses a custom Promise-like type called Async
-export interface JZZAsync<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
-    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
-  ): JZZAsync<TResult1 | TResult2>;
-}
-
-export interface JZZ {
-  info(): JZZInfo;
-  openMidiIn(name: string): JZZAsync<JZZPort>;
-  openMidiOut(name: string): JZZAsync<JZZPort>;
-  onChange(callback: () => void): void;
-}